diff --git a/.gitignore b/.gitignore index f23b3afd3..3b84fd0ce 100644 --- a/.gitignore +++ b/.gitignore @@ -11,7 +11,6 @@ yarn-error.log # Project-generated directories coverage -dist node_modules # Other diff --git a/dist/esm/Document.js b/dist/esm/Document.js new file mode 100644 index 000000000..df6aac504 --- /dev/null +++ b/dist/esm/Document.js @@ -0,0 +1,437 @@ +import _extends from "@babel/runtime/helpers/esm/extends"; +import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties"; +import _typeof from "@babel/runtime/helpers/esm/typeof"; +import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck"; +import _createClass from "@babel/runtime/helpers/esm/createClass"; +import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized"; +import _inherits from "@babel/runtime/helpers/esm/inherits"; +import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn"; +import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf"; +import _defineProperty from "@babel/runtime/helpers/esm/defineProperty"; +var _excluded = ["url"]; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +/** + * Loads a PDF document. Passes it to all children. + */ +import React, { PureComponent } from 'react'; +import PropTypes from 'prop-types'; +import makeEventProps from 'make-event-props'; +import makeCancellable from 'make-cancellable-promise'; +import mergeClassNames from 'merge-class-names'; +import invariant from 'tiny-invariant'; +import warning from 'tiny-warning'; +import * as pdfjs from 'pdfjs-dist/legacy/build/pdf'; +import DocumentContext from './DocumentContext'; +import Message from './Message'; +import LinkService from './LinkService'; +import PasswordResponses from './PasswordResponses'; +import { cancelRunningTask, dataURItoByteString, displayCORSWarning, isArrayBuffer, isBlob, isBrowser, isDataURI, isFile, loadFromFile } from './shared/utils'; +import { eventProps, isClassName, isFile as isFileProp, isRef } from './shared/propTypes'; +var PDFDataRangeTransport = pdfjs.PDFDataRangeTransport; + +var Document = /*#__PURE__*/function (_PureComponent) { + _inherits(Document, _PureComponent); + + var _super = _createSuper(Document); + + function Document() { + var _this; + + _classCallCheck(this, Document); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + + _defineProperty(_assertThisInitialized(_this), "state", { + pdf: null + }); + + _defineProperty(_assertThisInitialized(_this), "viewer", { + scrollPageIntoView: function scrollPageIntoView(_ref) { + var dest = _ref.dest, + pageIndex = _ref.pageIndex, + pageNumber = _ref.pageNumber; + // Handling jumping to internal links target + var onItemClick = _this.props.onItemClick; // First, check if custom handling of onItemClick was provided + + if (onItemClick) { + onItemClick({ + dest: dest, + pageIndex: pageIndex, + pageNumber: pageNumber + }); + return; + } // If not, try to look for target page within the . + + + var page = _this.pages[pageIndex]; + + if (page) { + // Scroll to the page automatically + page.scrollIntoView(); + return; + } + + warning(false, "An internal link leading to page ".concat(pageNumber, " was clicked, but neither was provided with onItemClick nor it was able to find the page within itself. Either provide onItemClick to and handle navigating by yourself or ensure that all pages are rendered within .")); + } + }); + + _defineProperty(_assertThisInitialized(_this), "linkService", new LinkService()); + + _defineProperty(_assertThisInitialized(_this), "loadDocument", function () { + // If another rendering is in progress, let's cancel it + cancelRunningTask(_this.runningTask); // If another loading is in progress, let's destroy it + + if (_this.loadingTask) _this.loadingTask.destroy(); + var cancellable = makeCancellable(_this.findDocumentSource()); + _this.runningTask = cancellable; + cancellable.promise.then(function (source) { + _this.onSourceSuccess(); + + if (!source) { + return; + } + + _this.setState(function (prevState) { + if (!prevState.pdf) { + return null; + } + + return { + pdf: null + }; + }); + + var _this$props = _this.props, + options = _this$props.options, + onLoadProgress = _this$props.onLoadProgress, + onPassword = _this$props.onPassword; + _this.loadingTask = pdfjs.getDocument(_objectSpread(_objectSpread(_objectSpread({}, source), options), {}, { + isEvalSupported: false + })); + _this.loadingTask.onPassword = onPassword; + + if (onLoadProgress) { + _this.loadingTask.onProgress = onLoadProgress; + } + + var cancellable = makeCancellable(_this.loadingTask.promise); + _this.runningTask = cancellable; + cancellable.promise.then(function (pdf) { + _this.setState(function (prevState) { + if (prevState.pdf && prevState.pdf.fingerprint === pdf.fingerprint) { + return null; + } + + return { + pdf: pdf + }; + }, _this.onLoadSuccess); + })["catch"](function (error) { + _this.onLoadError(error); + }); + })["catch"](function (error) { + _this.onSourceError(error); + }); + }); + + _defineProperty(_assertThisInitialized(_this), "setupLinkService", function () { + var _this$props2 = _this.props, + externalLinkRel = _this$props2.externalLinkRel, + externalLinkTarget = _this$props2.externalLinkTarget; + + _this.linkService.setViewer(_this.viewer); + + _this.linkService.setExternalLinkRel(externalLinkRel); + + _this.linkService.setExternalLinkTarget(externalLinkTarget); + }); + + _defineProperty(_assertThisInitialized(_this), "onSourceSuccess", function () { + var onSourceSuccess = _this.props.onSourceSuccess; + if (onSourceSuccess) onSourceSuccess(); + }); + + _defineProperty(_assertThisInitialized(_this), "onSourceError", function (error) { + warning(error); + var onSourceError = _this.props.onSourceError; + if (onSourceError) onSourceError(error); + }); + + _defineProperty(_assertThisInitialized(_this), "onLoadSuccess", function () { + var onLoadSuccess = _this.props.onLoadSuccess; + var pdf = _this.state.pdf; + if (onLoadSuccess) onLoadSuccess(pdf); + _this.pages = new Array(pdf.numPages); + + _this.linkService.setDocument(pdf); + }); + + _defineProperty(_assertThisInitialized(_this), "onLoadError", function (error) { + _this.setState({ + pdf: false + }); + + warning(error); + var onLoadError = _this.props.onLoadError; + if (onLoadError) onLoadError(error); + }); + + _defineProperty(_assertThisInitialized(_this), "findDocumentSource", function () { + return new Promise(function (resolve) { + var file = _this.props.file; + + if (!file) { + resolve(null); + } // File is a string + + + if (typeof file === 'string') { + if (isDataURI(file)) { + var fileByteString = dataURItoByteString(file); + resolve({ + data: fileByteString + }); + } + + displayCORSWarning(); + resolve({ + url: file + }); + } // File is PDFDataRangeTransport + + + if (file instanceof PDFDataRangeTransport) { + resolve({ + range: file + }); + } // File is an ArrayBuffer + + + if (isArrayBuffer(file)) { + resolve({ + data: file + }); + } + /** + * The cases below are browser-only. + * If you're running on a non-browser environment, these cases will be of no use. + */ + + + if (isBrowser) { + // File is a Blob + if (isBlob(file) || isFile(file)) { + loadFromFile(file).then(function (data) { + resolve({ + data: data + }); + }); + return; + } + } // At this point, file must be an object + + + invariant(_typeof(file) === 'object', 'Invalid parameter in file, need either Uint8Array, string or a parameter object'); + invariant(file.url || file.data || file.range, 'Invalid parameter object: need either .data, .range or .url'); // File .url is a string + + if (typeof file.url === 'string') { + if (isDataURI(file.url)) { + var url = file.url, + otherParams = _objectWithoutProperties(file, _excluded); + + var _fileByteString = dataURItoByteString(url); + + resolve(_objectSpread({ + data: _fileByteString + }, otherParams)); + } + + displayCORSWarning(); + } + + resolve(file); + }); + }); + + _defineProperty(_assertThisInitialized(_this), "registerPage", function (pageIndex, ref) { + _this.pages[pageIndex] = ref; + }); + + _defineProperty(_assertThisInitialized(_this), "unregisterPage", function (pageIndex) { + delete _this.pages[pageIndex]; + }); + + return _this; + } + + _createClass(Document, [{ + key: "componentDidMount", + value: function componentDidMount() { + this.loadDocument(); + this.setupLinkService(); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var file = this.props.file; + + if (file !== prevProps.file) { + this.loadDocument(); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + // If rendering is in progress, let's cancel it + cancelRunningTask(this.runningTask); // If loading is in progress, let's destroy it + + if (this.loadingTask) this.loadingTask.destroy(); + } + }, { + key: "childContext", + get: function get() { + var linkService = this.linkService, + registerPage = this.registerPage, + unregisterPage = this.unregisterPage; + var _this$props3 = this.props, + imageResourcesPath = _this$props3.imageResourcesPath, + renderMode = _this$props3.renderMode, + rotate = _this$props3.rotate; + var pdf = this.state.pdf; + return { + imageResourcesPath: imageResourcesPath, + linkService: linkService, + pdf: pdf, + registerPage: registerPage, + renderMode: renderMode, + rotate: rotate, + unregisterPage: unregisterPage + }; + } + }, { + key: "eventProps", + get: function get() { + var _this2 = this; + + return makeEventProps(this.props, function () { + return _this2.state.pdf; + }); + } + /** + * Called when a document source is resolved correctly + */ + + }, { + key: "renderChildren", + value: function renderChildren() { + var children = this.props.children; + return /*#__PURE__*/React.createElement(DocumentContext.Provider, { + value: this.childContext + }, children); + } + }, { + key: "renderContent", + value: function renderContent() { + var file = this.props.file; + var pdf = this.state.pdf; + + if (!file) { + var noData = this.props.noData; + return /*#__PURE__*/React.createElement(Message, { + type: "no-data" + }, typeof noData === 'function' ? noData() : noData); + } + + if (pdf === null) { + var loading = this.props.loading; + return /*#__PURE__*/React.createElement(Message, { + type: "loading" + }, typeof loading === 'function' ? loading() : loading); + } + + if (pdf === false) { + var error = this.props.error; + return /*#__PURE__*/React.createElement(Message, { + type: "error" + }, typeof error === 'function' ? error() : error); + } + + return this.renderChildren(); + } + }, { + key: "render", + value: function render() { + var _this$props4 = this.props, + className = _this$props4.className, + inputRef = _this$props4.inputRef; + return /*#__PURE__*/React.createElement("div", _extends({ + className: mergeClassNames('react-pdf__Document', className), + ref: inputRef + }, this.eventProps), this.renderContent()); + } + }]); + + return Document; +}(PureComponent); + +export { Document as default }; +Document.defaultProps = { + error: 'Failed to load PDF file.', + loading: 'Loading PDF…', + noData: 'No PDF file specified.', + onPassword: function onPassword(callback, reason) { + switch (reason) { + case PasswordResponses.NEED_PASSWORD: + { + // eslint-disable-next-line no-alert + var password = prompt('Enter the password to open this PDF file.'); + callback(password); + break; + } + + case PasswordResponses.INCORRECT_PASSWORD: + { + // eslint-disable-next-line no-alert + var _password = prompt('Invalid password. Please try again.'); + + callback(_password); + break; + } + + default: + } + } +}; +var isFunctionOrNode = PropTypes.oneOfType([PropTypes.func, PropTypes.node]); +Document.propTypes = _objectSpread(_objectSpread({}, eventProps), {}, { + children: PropTypes.node, + className: isClassName, + error: isFunctionOrNode, + externalLinkRel: PropTypes.string, + externalLinkTarget: PropTypes.string, + file: isFileProp, + imageResourcesPath: PropTypes.string, + inputRef: isRef, + loading: isFunctionOrNode, + noData: isFunctionOrNode, + onItemClick: PropTypes.func, + onLoadError: PropTypes.func, + onLoadProgress: PropTypes.func, + onLoadSuccess: PropTypes.func, + onPassword: PropTypes.func, + onSourceError: PropTypes.func, + onSourceSuccess: PropTypes.func, + rotate: PropTypes.number +}); \ No newline at end of file diff --git a/dist/esm/DocumentContext.js b/dist/esm/DocumentContext.js new file mode 100644 index 000000000..2831aac9e --- /dev/null +++ b/dist/esm/DocumentContext.js @@ -0,0 +1,2 @@ +import { createContext } from 'react'; +export default /*#__PURE__*/createContext(null); \ No newline at end of file diff --git a/dist/esm/LinkService.js b/dist/esm/LinkService.js new file mode 100644 index 000000000..56c45f62e --- /dev/null +++ b/dist/esm/LinkService.js @@ -0,0 +1,160 @@ +import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck"; +import _createClass from "@babel/runtime/helpers/esm/createClass"; + +/* Copyright 2015 Mozilla Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import invariant from 'tiny-invariant'; +var DEFAULT_LINK_REL = 'noopener noreferrer nofollow'; + +var LinkService = /*#__PURE__*/function () { + function LinkService() { + _classCallCheck(this, LinkService); + + this.externalLinkTarget = null; + this.externalLinkRel = null; + } + + _createClass(LinkService, [{ + key: "setDocument", + value: function setDocument(pdfDocument) { + this.pdfDocument = pdfDocument; + } + }, { + key: "setViewer", + value: function setViewer(pdfViewer) { + this.pdfViewer = pdfViewer; + } + }, { + key: "setExternalLinkRel", + value: function setExternalLinkRel(externalLinkRel) { + this.externalLinkRel = externalLinkRel; + } + }, { + key: "setExternalLinkTarget", + value: function setExternalLinkTarget(externalLinkTarget) { + this.externalLinkTarget = externalLinkTarget; + } + }, { + key: "setHistory", + value: function setHistory() {} + }, { + key: "pagesCount", + get: function get() { + return this.pdfDocument ? this.pdfDocument.numPages : 0; + } + }, { + key: "page", + get: function get() { + return this.pdfViewer.currentPageNumber; + }, + set: function set(value) { + this.pdfViewer.currentPageNumber = value; + } + }, { + key: "rotation", + get: function get() { + return 0; + }, + set: function set(value) {} + }, { + key: "goToDestination", + value: function goToDestination(dest) { + var _this = this; + + new Promise(function (resolve) { + if (typeof dest === 'string') { + _this.pdfDocument.getDestination(dest).then(resolve); + } else if (Array.isArray(dest)) { + resolve(dest); + } else { + dest.then(resolve); + } + }).then(function (explicitDest) { + invariant(Array.isArray(explicitDest), "\"".concat(explicitDest, "\" is not a valid destination array.")); + var destRef = explicitDest[0]; + new Promise(function (resolve) { + if (destRef instanceof Object) { + _this.pdfDocument.getPageIndex(destRef).then(function (pageIndex) { + resolve(pageIndex); + })["catch"](function () { + invariant(false, "\"".concat(destRef, "\" is not a valid page reference.")); + }); + } else if (typeof destRef === 'number') { + resolve(destRef); + } else { + invariant(false, "\"".concat(destRef, "\" is not a valid destination reference.")); + } + }).then(function (pageIndex) { + var pageNumber = pageIndex + 1; + invariant(pageNumber >= 1 && pageNumber <= _this.pagesCount, "\"".concat(pageNumber, "\" is not a valid page number.")); + + _this.pdfViewer.scrollPageIntoView({ + dest: dest, + pageIndex: pageIndex, + pageNumber: pageNumber + }); + }); + }); + } + }, { + key: "navigateTo", + value: function navigateTo(dest) { + this.goToDestination(dest); + } + }, { + key: "goToPage", + value: function goToPage() {} + }, { + key: "addLinkAttributes", + value: function addLinkAttributes(link, url, newWindow) { + link.href = url; + link.rel = this.externalLinkRel || DEFAULT_LINK_REL; + link.target = newWindow ? '_blank' : this.externalLinkTarget || ''; + } + }, { + key: "getDestinationHash", + value: function getDestinationHash() { + return '#'; + } + }, { + key: "getAnchorUrl", + value: function getAnchorUrl() { + return '#'; + } + }, { + key: "setHash", + value: function setHash() {} + }, { + key: "executeNamedAction", + value: function executeNamedAction() {} + }, { + key: "cachePageRef", + value: function cachePageRef() {} + }, { + key: "isPageVisible", + value: function isPageVisible() { + return true; + } + }, { + key: "isPageCached", + value: function isPageCached() { + return true; + } + }]); + + return LinkService; +}(); + +export { LinkService as default }; \ No newline at end of file diff --git a/dist/esm/Message.js b/dist/esm/Message.js new file mode 100644 index 000000000..ddee4baf6 --- /dev/null +++ b/dist/esm/Message.js @@ -0,0 +1,13 @@ +import React from 'react'; +import PropTypes from 'prop-types'; +export default function Message(_ref) { + var children = _ref.children, + type = _ref.type; + return /*#__PURE__*/React.createElement("div", { + className: "react-pdf__message react-pdf__message--".concat(type) + }, children); +} +Message.propTypes = { + children: PropTypes.node, + type: PropTypes.oneOf(['error', 'loading', 'no-data']).isRequired +}; \ No newline at end of file diff --git a/dist/esm/Outline.js b/dist/esm/Outline.js new file mode 100644 index 000000000..7c7a15915 --- /dev/null +++ b/dist/esm/Outline.js @@ -0,0 +1,201 @@ +import _extends from "@babel/runtime/helpers/esm/extends"; +import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck"; +import _createClass from "@babel/runtime/helpers/esm/createClass"; +import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized"; +import _inherits from "@babel/runtime/helpers/esm/inherits"; +import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn"; +import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf"; +import _defineProperty from "@babel/runtime/helpers/esm/defineProperty"; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +import React, { PureComponent } from 'react'; +import PropTypes from 'prop-types'; +import makeCancellable from 'make-cancellable-promise'; +import makeEventProps from 'make-event-props'; +import mergeClassNames from 'merge-class-names'; +import invariant from 'tiny-invariant'; +import warning from 'tiny-warning'; +import DocumentContext from './DocumentContext'; +import OutlineContext from './OutlineContext'; +import OutlineItem from './OutlineItem'; +import { cancelRunningTask } from './shared/utils'; +import { eventProps, isClassName, isPdf, isRef } from './shared/propTypes'; +export var OutlineInternal = /*#__PURE__*/function (_PureComponent) { + _inherits(OutlineInternal, _PureComponent); + + var _super = _createSuper(OutlineInternal); + + function OutlineInternal() { + var _this; + + _classCallCheck(this, OutlineInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + + _defineProperty(_assertThisInitialized(_this), "state", { + outline: null + }); + + _defineProperty(_assertThisInitialized(_this), "loadOutline", function () { + var pdf = _this.props.pdf; + + _this.setState(function (prevState) { + if (!prevState.outline) { + return null; + } + + return { + outline: null + }; + }); + + var cancellable = makeCancellable(pdf.getOutline()); + _this.runningTask = cancellable; + cancellable.promise.then(function (outline) { + _this.setState({ + outline: outline + }, _this.onLoadSuccess); + })["catch"](function (error) { + _this.onLoadError(error); + }); + }); + + _defineProperty(_assertThisInitialized(_this), "onLoadSuccess", function () { + var onLoadSuccess = _this.props.onLoadSuccess; + var outline = _this.state.outline; + if (onLoadSuccess) onLoadSuccess(outline); + }); + + _defineProperty(_assertThisInitialized(_this), "onLoadError", function (error) { + _this.setState({ + outline: false + }); + + warning(error); + var onLoadError = _this.props.onLoadError; + if (onLoadError) onLoadError(error); + }); + + _defineProperty(_assertThisInitialized(_this), "onItemClick", function (_ref) { + var dest = _ref.dest, + pageIndex = _ref.pageIndex, + pageNumber = _ref.pageNumber; + var onItemClick = _this.props.onItemClick; + + if (onItemClick) { + onItemClick({ + dest: dest, + pageIndex: pageIndex, + pageNumber: pageNumber + }); + } + }); + + return _this; + } + + _createClass(OutlineInternal, [{ + key: "componentDidMount", + value: function componentDidMount() { + var pdf = this.props.pdf; + invariant(pdf, 'Attempted to load an outline, but no document was specified.'); + this.loadOutline(); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var pdf = this.props.pdf; + + if (prevProps.pdf && pdf !== prevProps.pdf) { + this.loadOutline(); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + cancelRunningTask(this.runningTask); + } + }, { + key: "childContext", + get: function get() { + return { + onClick: this.onItemClick + }; + } + }, { + key: "eventProps", + get: function get() { + var _this2 = this; + + return makeEventProps(this.props, function () { + return _this2.state.outline; + }); + } + /** + * Called when an outline is read successfully + */ + + }, { + key: "renderOutline", + value: function renderOutline() { + var outline = this.state.outline; + return /*#__PURE__*/React.createElement("ul", null, outline.map(function (item, itemIndex) { + return /*#__PURE__*/React.createElement(OutlineItem, { + key: typeof item.destination === 'string' ? item.destination : itemIndex, + item: item + }); + })); + } + }, { + key: "render", + value: function render() { + var pdf = this.props.pdf; + var outline = this.state.outline; + + if (!pdf || !outline) { + return null; + } + + var _this$props = this.props, + className = _this$props.className, + inputRef = _this$props.inputRef; + return /*#__PURE__*/React.createElement("div", _extends({ + className: mergeClassNames('react-pdf__Outline', className), + ref: inputRef + }, this.eventProps), /*#__PURE__*/React.createElement(OutlineContext.Provider, { + value: this.childContext + }, this.renderOutline())); + } + }]); + + return OutlineInternal; +}(PureComponent); +OutlineInternal.propTypes = _objectSpread({ + className: isClassName, + inputRef: isRef, + onItemClick: PropTypes.func, + onLoadError: PropTypes.func, + onLoadSuccess: PropTypes.func, + pdf: isPdf +}, eventProps); + +function Outline(props, ref) { + return /*#__PURE__*/React.createElement(DocumentContext.Consumer, null, function (context) { + return /*#__PURE__*/React.createElement(OutlineInternal, _extends({ + ref: ref + }, context, props)); + }); +} + +export default /*#__PURE__*/React.forwardRef(Outline); \ No newline at end of file diff --git a/dist/esm/OutlineContext.js b/dist/esm/OutlineContext.js new file mode 100644 index 000000000..2831aac9e --- /dev/null +++ b/dist/esm/OutlineContext.js @@ -0,0 +1,2 @@ +import { createContext } from 'react'; +export default /*#__PURE__*/createContext(null); \ No newline at end of file diff --git a/dist/esm/OutlineItem.js b/dist/esm/OutlineItem.js new file mode 100644 index 000000000..ea06da084 --- /dev/null +++ b/dist/esm/OutlineItem.js @@ -0,0 +1,179 @@ +import _extends from "@babel/runtime/helpers/esm/extends"; +import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties"; +import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray"; +import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck"; +import _createClass from "@babel/runtime/helpers/esm/createClass"; +import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized"; +import _inherits from "@babel/runtime/helpers/esm/inherits"; +import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn"; +import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf"; +import _defineProperty from "@babel/runtime/helpers/esm/defineProperty"; +var _excluded = ["item"]; + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +import React, { PureComponent } from 'react'; +import PropTypes from 'prop-types'; +import DocumentContext from './DocumentContext'; +import OutlineContext from './OutlineContext'; +import Ref from './Ref'; +import { isDefined } from './shared/utils'; +import { isPdf } from './shared/propTypes'; +export var OutlineItemInternal = /*#__PURE__*/function (_PureComponent) { + _inherits(OutlineItemInternal, _PureComponent); + + var _super = _createSuper(OutlineItemInternal); + + function OutlineItemInternal() { + var _this; + + _classCallCheck(this, OutlineItemInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + + _defineProperty(_assertThisInitialized(_this), "getDestination", function () { + return new Promise(function (resolve, reject) { + var _this$props = _this.props, + item = _this$props.item, + pdf = _this$props.pdf; + + if (!isDefined(_this.destination)) { + if (typeof item.dest === 'string') { + pdf.getDestination(item.dest).then(resolve)["catch"](reject); + } else { + resolve(item.dest); + } + } + + return _this.destination; + }).then(function (destination) { + _this.destination = destination; + return destination; + }); + }); + + _defineProperty(_assertThisInitialized(_this), "getPageIndex", function () { + return new Promise(function (resolve, reject) { + var pdf = _this.props.pdf; + + if (isDefined(_this.pageIndex)) { + resolve(_this.pageIndex); + } + + _this.getDestination().then(function (destination) { + if (!destination) { + return; + } + + var _destination = _slicedToArray(destination, 1), + ref = _destination[0]; + + pdf.getPageIndex(new Ref(ref)).then(resolve)["catch"](reject); + }); + }).then(function (pageIndex) { + _this.pageIndex = pageIndex; + return _this.pageIndex; + }); + }); + + _defineProperty(_assertThisInitialized(_this), "getPageNumber", function () { + return new Promise(function (resolve, reject) { + if (isDefined(_this.pageNumber)) { + resolve(_this.pageNumber); + } + + _this.getPageIndex().then(function (pageIndex) { + resolve(pageIndex + 1); + })["catch"](reject); + }).then(function (pageNumber) { + _this.pageNumber = pageNumber; + return pageNumber; + }); + }); + + _defineProperty(_assertThisInitialized(_this), "onClick", function (event) { + var onClick = _this.props.onClick; + event.preventDefault(); + + if (!onClick) { + return false; + } + + return Promise.all([_this.getDestination(), _this.getPageIndex(), _this.getPageNumber()]).then(function (_ref) { + var _ref2 = _slicedToArray(_ref, 3), + dest = _ref2[0], + pageIndex = _ref2[1], + pageNumber = _ref2[2]; + + onClick({ + dest: dest, + pageIndex: pageIndex, + pageNumber: pageNumber + }); + }); + }); + + return _this; + } + + _createClass(OutlineItemInternal, [{ + key: "renderSubitems", + value: function renderSubitems() { + var _this$props2 = this.props, + item = _this$props2.item, + otherProps = _objectWithoutProperties(_this$props2, _excluded); + + if (!item.items || !item.items.length) { + return null; + } + + var subitems = item.items; + return /*#__PURE__*/React.createElement("ul", null, subitems.map(function (subitem, subitemIndex) { + return /*#__PURE__*/React.createElement(OutlineItemInternal, _extends({ + key: typeof subitem.destination === 'string' ? subitem.destination : subitemIndex, + item: subitem + }, otherProps)); + })); + } + }, { + key: "render", + value: function render() { + var item = this.props.item; + return /*#__PURE__*/React.createElement("li", null, /*#__PURE__*/React.createElement("a", { + href: "#", + onClick: this.onClick + }, item.title), this.renderSubitems()); + } + }]); + + return OutlineItemInternal; +}(PureComponent); +var isDestination = PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.any)]); +OutlineItemInternal.propTypes = { + item: PropTypes.shape({ + dest: isDestination, + items: PropTypes.arrayOf(PropTypes.shape({ + dest: isDestination, + title: PropTypes.string + })), + title: PropTypes.string + }).isRequired, + onClick: PropTypes.func, + pdf: isPdf.isRequired +}; + +var OutlineItem = function OutlineItem(props) { + return /*#__PURE__*/React.createElement(DocumentContext.Consumer, null, function (documentContext) { + return /*#__PURE__*/React.createElement(OutlineContext.Consumer, null, function (outlineContext) { + return /*#__PURE__*/React.createElement(OutlineItemInternal, _extends({}, documentContext, outlineContext, props)); + }); + }); +}; + +export default OutlineItem; \ No newline at end of file diff --git a/dist/esm/Page.js b/dist/esm/Page.js new file mode 100644 index 000000000..3494acb8d --- /dev/null +++ b/dist/esm/Page.js @@ -0,0 +1,465 @@ +import _extends from "@babel/runtime/helpers/esm/extends"; +import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck"; +import _createClass from "@babel/runtime/helpers/esm/createClass"; +import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized"; +import _inherits from "@babel/runtime/helpers/esm/inherits"; +import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn"; +import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf"; +import _defineProperty from "@babel/runtime/helpers/esm/defineProperty"; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +import React, { createRef, PureComponent } from 'react'; +import PropTypes from 'prop-types'; +import makeCancellable from 'make-cancellable-promise'; +import makeEventProps from 'make-event-props'; +import mergeClassNames from 'merge-class-names'; +import mergeRefs from 'merge-refs'; +import invariant from 'tiny-invariant'; +import warning from 'tiny-warning'; +import DocumentContext from './DocumentContext'; +import PageContext from './PageContext'; +import Message from './Message'; +import PageCanvas from './Page/PageCanvas'; +import PageSVG from './Page/PageSVG'; +import TextLayer from './Page/TextLayer'; +import AnnotationLayer from './Page/AnnotationLayer'; +import { cancelRunningTask, isProvided, makePageCallback } from './shared/utils'; +import { eventProps, isClassName, isPageIndex, isPageNumber, isPdf, isRef, isRenderMode, isRotate } from './shared/propTypes'; +var defaultScale = 1; +export var PageInternal = /*#__PURE__*/function (_PureComponent) { + _inherits(PageInternal, _PureComponent); + + var _super = _createSuper(PageInternal); + + function PageInternal() { + var _this; + + _classCallCheck(this, PageInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + + _defineProperty(_assertThisInitialized(_this), "state", { + page: null + }); + + _defineProperty(_assertThisInitialized(_this), "pageElement", /*#__PURE__*/createRef()); + + _defineProperty(_assertThisInitialized(_this), "onLoadSuccess", function () { + var _this$props = _this.props, + onLoadSuccess = _this$props.onLoadSuccess, + registerPage = _this$props.registerPage; + var page = _this.state.page; + + if (onLoadSuccess) { + if (!page || !_this.scale) { + return; + } + + onLoadSuccess(makePageCallback(page, _this.scale)); + } + + if (registerPage) registerPage(_this.pageIndex, _this.pageElement.current); + }); + + _defineProperty(_assertThisInitialized(_this), "onLoadError", function (error) { + _this.setState({ + page: false + }); + + warning(error); + var onLoadError = _this.props.onLoadError; + if (onLoadError) onLoadError(error); + }); + + _defineProperty(_assertThisInitialized(_this), "loadPage", function () { + var pdf = _this.props.pdf; + + var pageNumber = _this.getPageNumber(); + + if (!pageNumber) { + return; + } + + _this.setState(function (prevState) { + if (!prevState.page) { + return null; + } + + return { + page: null + }; + }); + + var cancellable = makeCancellable(pdf.getPage(pageNumber)); + _this.runningTask = cancellable; + cancellable.promise.then(function (page) { + _this.setState({ + page: page + }, _this.onLoadSuccess); + })["catch"](function (error) { + _this.onLoadError(error); + }); + }); + + return _this; + } + + _createClass(PageInternal, [{ + key: "componentDidMount", + value: function componentDidMount() { + var pdf = this.props.pdf; + invariant(pdf, 'Attempted to load a page, but no document was specified.'); + this.loadPage(); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var pdf = this.props.pdf; + + if (prevProps.pdf && pdf !== prevProps.pdf || this.getPageNumber() !== this.getPageNumber(prevProps)) { + var unregisterPage = this.props.unregisterPage; + if (unregisterPage) unregisterPage(this.getPageIndex(prevProps)); + this.loadPage(); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + var unregisterPage = this.props.unregisterPage; + if (unregisterPage) unregisterPage(this.pageIndex); + cancelRunningTask(this.runningTask); + } + }, { + key: "childContext", + get: function get() { + var page = this.state.page; + + if (!page) { + return {}; + } + + var _this$props2 = this.props, + canvasBackground = _this$props2.canvasBackground, + customTextRenderer = _this$props2.customTextRenderer, + onGetAnnotationsError = _this$props2.onGetAnnotationsError, + onGetAnnotationsSuccess = _this$props2.onGetAnnotationsSuccess, + onGetTextError = _this$props2.onGetTextError, + onGetTextSuccess = _this$props2.onGetTextSuccess, + onRenderAnnotationLayerError = _this$props2.onRenderAnnotationLayerError, + onRenderAnnotationLayerSuccess = _this$props2.onRenderAnnotationLayerSuccess, + onRenderError = _this$props2.onRenderError, + onRenderSuccess = _this$props2.onRenderSuccess, + renderForms = _this$props2.renderForms, + renderInteractiveForms = _this$props2.renderInteractiveForms; + return { + canvasBackground: canvasBackground, + customTextRenderer: customTextRenderer, + onGetAnnotationsError: onGetAnnotationsError, + onGetAnnotationsSuccess: onGetAnnotationsSuccess, + onGetTextError: onGetTextError, + onGetTextSuccess: onGetTextSuccess, + onRenderAnnotationLayerError: onRenderAnnotationLayerError, + onRenderAnnotationLayerSuccess: onRenderAnnotationLayerSuccess, + onRenderError: onRenderError, + onRenderSuccess: onRenderSuccess, + page: page, + renderForms: renderForms !== null && renderForms !== void 0 ? renderForms : renderInteractiveForms, + // For backward compatibility + rotate: this.rotate, + scale: this.scale + }; + } + /** + * Called when a page is loaded successfully + */ + + }, { + key: "getPageIndex", + value: function getPageIndex() { + var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props; + + if (isProvided(props.pageNumber)) { + return props.pageNumber - 1; + } + + if (isProvided(props.pageIndex)) { + return props.pageIndex; + } + + return null; + } + }, { + key: "getPageNumber", + value: function getPageNumber() { + var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props; + + if (isProvided(props.pageNumber)) { + return props.pageNumber; + } + + if (isProvided(props.pageIndex)) { + return props.pageIndex + 1; + } + + return null; + } + }, { + key: "pageIndex", + get: function get() { + return this.getPageIndex(); + } + }, { + key: "pageNumber", + get: function get() { + return this.getPageNumber(); + } + }, { + key: "rotate", + get: function get() { + var rotate = this.props.rotate; + + if (isProvided(rotate)) { + return rotate; + } + + var page = this.state.page; + + if (!page) { + return null; + } + + return page.rotate; + } + }, { + key: "scale", + get: function get() { + var page = this.state.page; + + if (!page) { + return null; + } + + var _this$props3 = this.props, + scale = _this$props3.scale, + width = _this$props3.width, + height = _this$props3.height; + var rotate = this.rotate; // Be default, we'll render page at 100% * scale width. + + var pageScale = 1; // Passing scale explicitly null would cause the page not to render + + var scaleWithDefault = scale === null ? defaultScale : scale; // If width/height is defined, calculate the scale of the page so it could be of desired width. + + if (width || height) { + var viewport = page.getViewport({ + scale: 1, + rotation: rotate + }); + pageScale = width ? width / viewport.width : height / viewport.height; + } + + return scaleWithDefault * pageScale; + } + }, { + key: "eventProps", + get: function get() { + var _this2 = this; + + return makeEventProps(this.props, function () { + var page = _this2.state.page; + + if (!page) { + return page; + } + + return makePageCallback(page, _this2.scale); + }); + } + }, { + key: "pageKey", + get: function get() { + var page = this.state.page; + return "".concat(page.pageIndex, "@").concat(this.scale, "/").concat(this.rotate); + } + }, { + key: "pageKeyNoScale", + get: function get() { + var page = this.state.page; + return "".concat(page.pageIndex, "/").concat(this.rotate); + } + }, { + key: "renderMainLayer", + value: function renderMainLayer() { + var _this$props4 = this.props, + canvasRef = _this$props4.canvasRef, + renderMode = _this$props4.renderMode; + + switch (renderMode) { + case 'none': + return null; + + case 'svg': + return /*#__PURE__*/React.createElement(PageSVG, { + key: "".concat(this.pageKeyNoScale, "_svg") + }); + + case 'canvas': + default: + return /*#__PURE__*/React.createElement(PageCanvas, { + key: "".concat(this.pageKey, "_canvas"), + canvasRef: canvasRef + }); + } + } + }, { + key: "renderTextLayer", + value: function renderTextLayer() { + var renderTextLayer = this.props.renderTextLayer; + + if (!renderTextLayer) { + return null; + } + + return /*#__PURE__*/React.createElement(TextLayer, { + key: "".concat(this.pageKey, "_text") + }); + } + }, { + key: "renderAnnotationLayer", + value: function renderAnnotationLayer() { + var renderAnnotationLayer = this.props.renderAnnotationLayer; + + if (!renderAnnotationLayer) { + return null; + } + /** + * As of now, PDF.js 2.0.943 returns warnings on unimplemented annotations in SVG mode. + * Therefore, as a fallback, we render "traditional" AnnotationLayer component. + */ + + + return /*#__PURE__*/React.createElement(AnnotationLayer, { + key: "".concat(this.pageKey, "_annotations") + }); + } + }, { + key: "renderChildren", + value: function renderChildren() { + var children = this.props.children; + return /*#__PURE__*/React.createElement(PageContext.Provider, { + value: this.childContext + }, this.renderMainLayer(), this.renderTextLayer(), this.renderAnnotationLayer(), children); + } + }, { + key: "renderContent", + value: function renderContent() { + var pageNumber = this.pageNumber; + var pdf = this.props.pdf; + var page = this.state.page; + + if (!pageNumber) { + var noData = this.props.noData; + return /*#__PURE__*/React.createElement(Message, { + type: "no-data" + }, typeof noData === 'function' ? noData() : noData); + } + + if (pdf === null || page === null) { + var loading = this.props.loading; + return /*#__PURE__*/React.createElement(Message, { + type: "loading" + }, typeof loading === 'function' ? loading() : loading); + } + + if (pdf === false || page === false) { + var error = this.props.error; + return /*#__PURE__*/React.createElement(Message, { + type: "error" + }, typeof error === 'function' ? error() : error); + } + + return this.renderChildren(); + } + }, { + key: "render", + value: function render() { + var pageNumber = this.pageNumber; + var _this$props5 = this.props, + className = _this$props5.className, + inputRef = _this$props5.inputRef; + return /*#__PURE__*/React.createElement("div", _extends({ + className: mergeClassNames('react-pdf__Page', className), + "data-page-number": pageNumber, + ref: mergeRefs(inputRef, this.pageElement), + style: { + position: 'relative' + } + }, this.eventProps), this.renderContent()); + } + }]); + + return PageInternal; +}(PureComponent); +PageInternal.defaultProps = { + error: 'Failed to load the page.', + loading: 'Loading page…', + noData: 'No page specified.', + renderAnnotationLayer: true, + renderForms: false, + renderMode: 'canvas', + renderTextLayer: true, + scale: defaultScale +}; +var isFunctionOrNode = PropTypes.oneOfType([PropTypes.func, PropTypes.node]); +PageInternal.propTypes = _objectSpread(_objectSpread({}, eventProps), {}, { + canvasBackground: PropTypes.string, + children: PropTypes.node, + className: isClassName, + customTextRenderer: PropTypes.func, + error: isFunctionOrNode, + height: PropTypes.number, + imageResourcesPath: PropTypes.string, + inputRef: isRef, + loading: isFunctionOrNode, + noData: isFunctionOrNode, + onGetTextError: PropTypes.func, + onGetTextSuccess: PropTypes.func, + onLoadError: PropTypes.func, + onLoadSuccess: PropTypes.func, + onRenderError: PropTypes.func, + onRenderSuccess: PropTypes.func, + pageIndex: isPageIndex, + pageNumber: isPageNumber, + pdf: isPdf, + registerPage: PropTypes.func, + renderAnnotationLayer: PropTypes.bool, + renderForms: PropTypes.bool, + renderInteractiveForms: PropTypes.bool, + // For backward compatibility + renderMode: isRenderMode, + renderTextLayer: PropTypes.bool, + rotate: isRotate, + scale: PropTypes.number, + unregisterPage: PropTypes.func, + width: PropTypes.number +}); + +function Page(props, ref) { + return /*#__PURE__*/React.createElement(DocumentContext.Consumer, null, function (context) { + return /*#__PURE__*/React.createElement(PageInternal, _extends({ + ref: ref + }, context, props)); + }); +} + +export default /*#__PURE__*/React.forwardRef(Page); \ No newline at end of file diff --git a/dist/esm/Page/AnnotationLayer.css b/dist/esm/Page/AnnotationLayer.css new file mode 100644 index 000000000..2713074cc --- /dev/null +++ b/dist/esm/Page/AnnotationLayer.css @@ -0,0 +1,232 @@ +/* Copyright 2014 Mozilla Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +:root { + --annotation-unfocused-field-background: url("data:image/svg+xml;charset=UTF-8,"); +} + +.annotationLayer section { + position: absolute; + text-align: initial; +} + +.annotationLayer .linkAnnotation > a, +.annotationLayer .buttonWidgetAnnotation.pushButton > a { + position: absolute; + font-size: 1em; + top: 0; + left: 0; + width: 100%; + height: 100%; +} + +.annotationLayer .buttonWidgetAnnotation.pushButton > canvas { + position: relative; + top: 0; + left: 0; + z-index: -1; +} + +.annotationLayer .linkAnnotation > a:hover, +.annotationLayer .buttonWidgetAnnotation.pushButton > a:hover { + opacity: 0.2; + background: rgba(255, 255, 0, 1); + box-shadow: 0 2px 10px rgba(255, 255, 0, 1); +} + +.annotationLayer .textAnnotation img { + position: absolute; + cursor: pointer; +} + +.annotationLayer .textWidgetAnnotation input, +.annotationLayer .textWidgetAnnotation textarea, +.annotationLayer .choiceWidgetAnnotation select, +.annotationLayer .buttonWidgetAnnotation.checkBox input, +.annotationLayer .buttonWidgetAnnotation.radioButton input { + background-image: var(--annotation-unfocused-field-background); + border: 1px solid transparent; + box-sizing: border-box; + font-size: 9px; + height: 100%; + margin: 0; + padding: 0 3px; + vertical-align: top; + width: 100%; +} + +.annotationLayer .choiceWidgetAnnotation select option { + padding: 0; +} + +.annotationLayer .buttonWidgetAnnotation.radioButton input { + border-radius: 50%; +} + +.annotationLayer .textWidgetAnnotation textarea { + font: message-box; + font-size: 9px; + resize: none; +} + +.annotationLayer .textWidgetAnnotation input[disabled], +.annotationLayer .textWidgetAnnotation textarea[disabled], +.annotationLayer .choiceWidgetAnnotation select[disabled], +.annotationLayer .buttonWidgetAnnotation.checkBox input[disabled], +.annotationLayer .buttonWidgetAnnotation.radioButton input[disabled] { + background: none; + border: 1px solid transparent; + cursor: not-allowed; +} + +.annotationLayer .textWidgetAnnotation input:hover, +.annotationLayer .textWidgetAnnotation textarea:hover, +.annotationLayer .choiceWidgetAnnotation select:hover, +.annotationLayer .buttonWidgetAnnotation.checkBox input:hover, +.annotationLayer .buttonWidgetAnnotation.radioButton input:hover { + border: 1px solid rgba(0, 0, 0, 1); +} + +.annotationLayer .textWidgetAnnotation input:focus, +.annotationLayer .textWidgetAnnotation textarea:focus, +.annotationLayer .choiceWidgetAnnotation select:focus { + background: none; + border: 1px solid transparent; +} + +.annotationLayer .textWidgetAnnotation input :focus, +.annotationLayer .textWidgetAnnotation textarea :focus, +.annotationLayer .choiceWidgetAnnotation select :focus, +.annotationLayer .buttonWidgetAnnotation.checkBox :focus, +.annotationLayer .buttonWidgetAnnotation.radioButton :focus { + background-image: none; + background-color: transparent; + outline: auto; +} + +.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:before, +.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:after, +.annotationLayer .buttonWidgetAnnotation.radioButton input:checked:before { + background-color: rgba(0, 0, 0, 1); + content: ''; + display: block; + position: absolute; +} + +.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:before, +.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:after { + height: 80%; + left: 45%; + width: 1px; +} + +.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:before { + transform: rotate(45deg); +} + +.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:after { + transform: rotate(-45deg); +} + +.annotationLayer .buttonWidgetAnnotation.radioButton input:checked:before { + border-radius: 50%; + height: 50%; + left: 30%; + top: 20%; + width: 50%; +} + +.annotationLayer .textWidgetAnnotation input.comb { + font-family: monospace; + padding-left: 2px; + padding-right: 0; +} + +.annotationLayer .textWidgetAnnotation input.comb:focus { + /* + * Letter spacing is placed on the right side of each character. Hence, the + * letter spacing of the last character may be placed outside the visible + * area, causing horizontal scrolling. We avoid this by extending the width + * when the element has focus and revert this when it loses focus. + */ + width: 103%; +} + +.annotationLayer .buttonWidgetAnnotation.checkBox input, +.annotationLayer .buttonWidgetAnnotation.radioButton input { + appearance: none; + padding: 0; +} + +.annotationLayer .popupWrapper { + position: absolute; + width: 20em; +} + +.annotationLayer .popup { + position: absolute; + z-index: 200; + max-width: 20em; + background-color: rgba(255, 255, 153, 1); + box-shadow: 0 2px 5px rgba(136, 136, 136, 1); + border-radius: 2px; + padding: 6px; + margin-left: 5px; + cursor: pointer; + font: message-box; + font-size: 9px; + white-space: normal; + word-wrap: break-word; +} + +.annotationLayer .popup > * { + font-size: 9px; +} + +.annotationLayer .popup h1 { + display: inline-block; +} + +.annotationLayer .popupDate { + display: inline-block; + margin-left: 5px; +} + +.annotationLayer .popupContent { + border-top: 1px solid rgba(51, 51, 51, 1); + margin-top: 2px; + padding-top: 2px; +} + +.annotationLayer .richText > * { + white-space: pre-wrap; +} + +.annotationLayer .highlightAnnotation, +.annotationLayer .underlineAnnotation, +.annotationLayer .squigglyAnnotation, +.annotationLayer .strikeoutAnnotation, +.annotationLayer .freeTextAnnotation, +.annotationLayer .lineAnnotation svg line, +.annotationLayer .squareAnnotation svg rect, +.annotationLayer .circleAnnotation svg ellipse, +.annotationLayer .polylineAnnotation svg polyline, +.annotationLayer .polygonAnnotation svg polygon, +.annotationLayer .caretAnnotation, +.annotationLayer .inkAnnotation svg polyline, +.annotationLayer .stampAnnotation, +.annotationLayer .fileAttachmentAnnotation { + cursor: pointer; +} diff --git a/dist/esm/Page/AnnotationLayer.js b/dist/esm/Page/AnnotationLayer.js new file mode 100644 index 000000000..385e726fb --- /dev/null +++ b/dist/esm/Page/AnnotationLayer.js @@ -0,0 +1,192 @@ +import _extends from "@babel/runtime/helpers/esm/extends"; +import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck"; +import _createClass from "@babel/runtime/helpers/esm/createClass"; +import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized"; +import _inherits from "@babel/runtime/helpers/esm/inherits"; +import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn"; +import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf"; +import _defineProperty from "@babel/runtime/helpers/esm/defineProperty"; + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +import React, { createRef, PureComponent } from 'react'; +import PropTypes from 'prop-types'; +import makeCancellable from 'make-cancellable-promise'; +import invariant from 'tiny-invariant'; +import warning from 'tiny-warning'; +import * as pdfjs from 'pdfjs-dist/legacy/build/pdf'; +import DocumentContext from '../DocumentContext'; +import PageContext from '../PageContext'; +import { cancelRunningTask } from '../shared/utils'; +import { isLinkService, isPage, isRotate } from '../shared/propTypes'; +export var AnnotationLayerInternal = /*#__PURE__*/function (_PureComponent) { + _inherits(AnnotationLayerInternal, _PureComponent); + + var _super = _createSuper(AnnotationLayerInternal); + + function AnnotationLayerInternal() { + var _this; + + _classCallCheck(this, AnnotationLayerInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + + _defineProperty(_assertThisInitialized(_this), "state", { + annotations: null + }); + + _defineProperty(_assertThisInitialized(_this), "layerElement", /*#__PURE__*/createRef()); + + _defineProperty(_assertThisInitialized(_this), "loadAnnotations", function () { + var page = _this.props.page; + var cancellable = makeCancellable(page.getAnnotations()); + _this.runningTask = cancellable; + cancellable.promise.then(function (annotations) { + _this.setState({ + annotations: annotations + }, _this.onLoadSuccess); + })["catch"](function (error) { + _this.onLoadError(error); + }); + }); + + _defineProperty(_assertThisInitialized(_this), "onLoadSuccess", function () { + var onGetAnnotationsSuccess = _this.props.onGetAnnotationsSuccess; + var annotations = _this.state.annotations; + if (onGetAnnotationsSuccess) onGetAnnotationsSuccess(annotations); + }); + + _defineProperty(_assertThisInitialized(_this), "onLoadError", function (error) { + _this.setState({ + annotations: false + }); + + warning(error); + var onGetAnnotationsError = _this.props.onGetAnnotationsError; + if (onGetAnnotationsError) onGetAnnotationsError(error); + }); + + _defineProperty(_assertThisInitialized(_this), "onRenderSuccess", function () { + var onRenderAnnotationLayerSuccess = _this.props.onRenderAnnotationLayerSuccess; + if (onRenderAnnotationLayerSuccess) onRenderAnnotationLayerSuccess(); + }); + + _defineProperty(_assertThisInitialized(_this), "onRenderError", function (error) { + warning(error); + var onRenderAnnotationLayerError = _this.props.onRenderAnnotationLayerError; + if (onRenderAnnotationLayerError) onRenderAnnotationLayerError(error); + }); + + return _this; + } + + _createClass(AnnotationLayerInternal, [{ + key: "componentDidMount", + value: function componentDidMount() { + var page = this.props.page; + invariant(page, 'Attempted to load page annotations, but no page was specified.'); + this.loadAnnotations(); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var _this$props = this.props, + page = _this$props.page, + renderForms = _this$props.renderForms; + + if (prevProps.page && page !== prevProps.page || renderForms !== prevProps.renderForms) { + this.loadAnnotations(); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + cancelRunningTask(this.runningTask); + } + }, { + key: "viewport", + get: function get() { + var _this$props2 = this.props, + page = _this$props2.page, + rotate = _this$props2.rotate, + scale = _this$props2.scale; + return page.getViewport({ + scale: scale, + rotation: rotate + }); + } + }, { + key: "renderAnnotationLayer", + value: function renderAnnotationLayer() { + var annotations = this.state.annotations; + + if (!annotations) { + return; + } + + var _this$props3 = this.props, + imageResourcesPath = _this$props3.imageResourcesPath, + linkService = _this$props3.linkService, + page = _this$props3.page, + renderForms = _this$props3.renderForms; + var viewport = this.viewport.clone({ + dontFlip: true + }); + var parameters = { + annotations: annotations, + div: this.layerElement.current, + imageResourcesPath: imageResourcesPath, + linkService: linkService, + page: page, + renderForms: renderForms, + viewport: viewport + }; + this.layerElement.current.innerHTML = ''; + + try { + pdfjs.AnnotationLayer.render(parameters); + this.onRenderSuccess(); + } catch (error) { + this.onRenderError(error); + } + } + }, { + key: "render", + value: function render() { + return /*#__PURE__*/React.createElement("div", { + className: "react-pdf__Page__annotations annotationLayer", + ref: this.layerElement + }, this.renderAnnotationLayer()); + } + }]); + + return AnnotationLayerInternal; +}(PureComponent); +AnnotationLayerInternal.propTypes = { + imageResourcesPath: PropTypes.string, + linkService: isLinkService.isRequired, + onGetAnnotationsError: PropTypes.func, + onGetAnnotationsSuccess: PropTypes.func, + onRenderAnnotationLayerError: PropTypes.func, + onRenderAnnotationLayerSuccess: PropTypes.func, + page: isPage, + renderForms: PropTypes.bool, + rotate: isRotate, + scale: PropTypes.number +}; + +var AnnotationLayer = function AnnotationLayer(props) { + return /*#__PURE__*/React.createElement(DocumentContext.Consumer, null, function (documentContext) { + return /*#__PURE__*/React.createElement(PageContext.Consumer, null, function (pageContext) { + return /*#__PURE__*/React.createElement(AnnotationLayerInternal, _extends({}, documentContext, pageContext, props)); + }); + }); +}; + +export default AnnotationLayer; \ No newline at end of file diff --git a/dist/esm/Page/PageCanvas.js b/dist/esm/Page/PageCanvas.js new file mode 100644 index 000000000..3fbdbc7e9 --- /dev/null +++ b/dist/esm/Page/PageCanvas.js @@ -0,0 +1,206 @@ +import _extends from "@babel/runtime/helpers/esm/extends"; +import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck"; +import _createClass from "@babel/runtime/helpers/esm/createClass"; +import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized"; +import _inherits from "@babel/runtime/helpers/esm/inherits"; +import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn"; +import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf"; +import _defineProperty from "@babel/runtime/helpers/esm/defineProperty"; + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +import React, { createRef, PureComponent } from 'react'; +import PropTypes from 'prop-types'; +import mergeRefs from 'merge-refs'; +import warning from 'tiny-warning'; +import * as pdfjs from 'pdfjs-dist/legacy/build/pdf'; +import PageContext from '../PageContext'; +import { getPixelRatio, isCancelException, makePageCallback } from '../shared/utils'; +import { isPage, isRef, isRotate } from '../shared/propTypes'; +var ANNOTATION_MODE = pdfjs.AnnotationMode; +export var PageCanvasInternal = /*#__PURE__*/function (_PureComponent) { + _inherits(PageCanvasInternal, _PureComponent); + + var _super = _createSuper(PageCanvasInternal); + + function PageCanvasInternal() { + var _this; + + _classCallCheck(this, PageCanvasInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + + _defineProperty(_assertThisInitialized(_this), "canvasElement", /*#__PURE__*/createRef()); + + _defineProperty(_assertThisInitialized(_this), "onRenderSuccess", function () { + _this.renderer = null; + var _this$props = _this.props, + onRenderSuccess = _this$props.onRenderSuccess, + page = _this$props.page, + scale = _this$props.scale; + if (onRenderSuccess) onRenderSuccess(makePageCallback(page, scale)); + }); + + _defineProperty(_assertThisInitialized(_this), "onRenderError", function (error) { + if (isCancelException(error)) { + return; + } + + warning(error); + var onRenderError = _this.props.onRenderError; + if (onRenderError) onRenderError(error); + }); + + _defineProperty(_assertThisInitialized(_this), "drawPageOnCanvas", function () { + var canvas = _this.canvasElement.current; + + if (!canvas) { + return null; + } + + var _assertThisInitialize = _assertThisInitialized(_this), + renderViewport = _assertThisInitialize.renderViewport, + viewport = _assertThisInitialize.viewport; + + var _this$props2 = _this.props, + canvasBackground = _this$props2.canvasBackground, + page = _this$props2.page, + renderForms = _this$props2.renderForms; + canvas.width = renderViewport.width; + canvas.height = renderViewport.height; + canvas.style.width = "".concat(Math.floor(viewport.width), "px"); + canvas.style.height = "".concat(Math.floor(viewport.height), "px"); + var renderContext = { + annotationMode: renderForms ? ANNOTATION_MODE.ENABLE_FORMS : ANNOTATION_MODE.ENABLE, + + get canvasContext() { + return canvas.getContext('2d'); + }, + + viewport: renderViewport + }; + + if (canvasBackground) { + renderContext.background = canvasBackground; + } // If another render is in progress, let's cancel it + + + _this.cancelRenderingTask(); + + _this.renderer = page.render(renderContext); + return _this.renderer.promise.then(_this.onRenderSuccess)["catch"](_this.onRenderError); + }); + + return _this; + } + + _createClass(PageCanvasInternal, [{ + key: "componentDidMount", + value: function componentDidMount() { + this.drawPageOnCanvas(); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var _this$props3 = this.props, + canvasBackground = _this$props3.canvasBackground, + page = _this$props3.page, + renderForms = _this$props3.renderForms; + + if (canvasBackground !== prevProps.canvasBackground || renderForms !== prevProps.renderForms) { + // Ensures the canvas will be re-rendered from scratch. Otherwise all form data will stay. + page.cleanup(); + this.drawPageOnCanvas(); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + this.cancelRenderingTask(); + var canvas = this.canvasElement.current; + /** + * 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; + } + } + }, { + key: "cancelRenderingTask", + value: function cancelRenderingTask() { + if (this.renderer) { + this.renderer.cancel(); + this.renderer = null; + } + } + /** + * Called when a page is rendered successfully. + */ + + }, { + key: "renderViewport", + get: function get() { + var _this$props4 = this.props, + page = _this$props4.page, + rotate = _this$props4.rotate, + scale = _this$props4.scale; + var pixelRatio = getPixelRatio(); + return page.getViewport({ + scale: scale * pixelRatio, + rotation: rotate + }); + } + }, { + key: "viewport", + get: function get() { + var _this$props5 = this.props, + page = _this$props5.page, + rotate = _this$props5.rotate, + scale = _this$props5.scale; + return page.getViewport({ + scale: scale, + rotation: rotate + }); + } + }, { + key: "render", + value: function render() { + var canvasRef = this.props.canvasRef; + return /*#__PURE__*/React.createElement("canvas", { + className: "react-pdf__Page__canvas", + dir: "ltr", + ref: mergeRefs(canvasRef, this.canvasElement), + style: { + display: 'block', + userSelect: 'none' + } + }); + } + }]); + + return PageCanvasInternal; +}(PureComponent); +PageCanvasInternal.propTypes = { + canvasBackground: PropTypes.string, + canvasRef: isRef, + onRenderError: PropTypes.func, + onRenderSuccess: PropTypes.func, + page: isPage.isRequired, + renderForms: PropTypes.bool, + rotate: isRotate, + scale: PropTypes.number.isRequired +}; +export default function PageCanvas(props) { + return /*#__PURE__*/React.createElement(PageContext.Consumer, null, function (context) { + return /*#__PURE__*/React.createElement(PageCanvasInternal, _extends({}, context, props)); + }); +} \ No newline at end of file diff --git a/dist/esm/Page/PageSVG.js b/dist/esm/Page/PageSVG.js new file mode 100644 index 000000000..ec2e32ee6 --- /dev/null +++ b/dist/esm/Page/PageSVG.js @@ -0,0 +1,155 @@ +import _extends from "@babel/runtime/helpers/esm/extends"; +import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck"; +import _createClass from "@babel/runtime/helpers/esm/createClass"; +import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized"; +import _inherits from "@babel/runtime/helpers/esm/inherits"; +import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn"; +import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf"; +import _defineProperty from "@babel/runtime/helpers/esm/defineProperty"; + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +import React, { PureComponent } from 'react'; +import PropTypes from 'prop-types'; +import warning from 'tiny-warning'; +import * as pdfjs from 'pdfjs-dist/legacy/build/pdf'; +import PageContext from '../PageContext'; +import { isCancelException, makePageCallback } from '../shared/utils'; +import { isPage, isRotate } from '../shared/propTypes'; +export var PageSVGInternal = /*#__PURE__*/function (_PureComponent) { + _inherits(PageSVGInternal, _PureComponent); + + var _super = _createSuper(PageSVGInternal); + + function PageSVGInternal() { + var _this; + + _classCallCheck(this, PageSVGInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + + _defineProperty(_assertThisInitialized(_this), "state", { + svg: null + }); + + _defineProperty(_assertThisInitialized(_this), "onRenderSuccess", function () { + _this.renderer = null; + var _this$props = _this.props, + onRenderSuccess = _this$props.onRenderSuccess, + page = _this$props.page, + scale = _this$props.scale; + if (onRenderSuccess) onRenderSuccess(makePageCallback(page, scale)); + }); + + _defineProperty(_assertThisInitialized(_this), "onRenderError", function (error) { + if (isCancelException(error)) { + return; + } + + warning(error); + var onRenderError = _this.props.onRenderError; + if (onRenderError) onRenderError(error); + }); + + _defineProperty(_assertThisInitialized(_this), "renderSVG", function () { + var page = _this.props.page; + _this.renderer = page.getOperatorList(); + return _this.renderer.then(function (operatorList) { + var svgGfx = new pdfjs.SVGGraphics(page.commonObjs, page.objs); + _this.renderer = svgGfx.getSVG(operatorList, _this.viewport).then(function (svg) { + _this.setState({ + svg: svg + }, _this.onRenderSuccess); + })["catch"](_this.onRenderError); + })["catch"](_this.onRenderError); + }); + + _defineProperty(_assertThisInitialized(_this), "drawPageOnContainer", function (element) { + var svg = _this.state.svg; + + if (!element || !svg) { + return; + } // Append SVG element to the main container, if this hasn't been done already + + + if (!element.firstElementChild) { + element.appendChild(svg); + } + + var _this$viewport = _this.viewport, + width = _this$viewport.width, + height = _this$viewport.height; + svg.setAttribute('width', width); + svg.setAttribute('height', height); + }); + + return _this; + } + + _createClass(PageSVGInternal, [{ + key: "componentDidMount", + value: function componentDidMount() { + this.renderSVG(); + } + /** + * Called when a page is rendered successfully. + */ + + }, { + key: "viewport", + get: function get() { + var _this$props2 = this.props, + page = _this$props2.page, + rotate = _this$props2.rotate, + scale = _this$props2.scale; + return page.getViewport({ + scale: scale, + rotation: rotate + }); + } + }, { + key: "render", + value: function render() { + var _this2 = this; + + var _this$viewport2 = this.viewport, + width = _this$viewport2.width, + height = _this$viewport2.height; + return /*#__PURE__*/React.createElement("div", { + className: "react-pdf__Page__svg" // Note: This cannot be shortened, as we need this function to be called with each render. + , + ref: function ref(_ref) { + return _this2.drawPageOnContainer(_ref); + }, + style: { + display: 'block', + backgroundColor: 'white', + overflow: 'hidden', + width: width, + height: height, + userSelect: 'none' + } + }); + } + }]); + + return PageSVGInternal; +}(PureComponent); +PageSVGInternal.propTypes = { + onRenderError: PropTypes.func, + onRenderSuccess: PropTypes.func, + page: isPage.isRequired, + rotate: isRotate, + scale: PropTypes.number.isRequired +}; +export default function PageSVG(props) { + return /*#__PURE__*/React.createElement(PageContext.Consumer, null, function (context) { + return /*#__PURE__*/React.createElement(PageSVGInternal, _extends({}, context, props)); + }); +} \ No newline at end of file diff --git a/dist/esm/Page/TextLayer.js b/dist/esm/Page/TextLayer.js new file mode 100644 index 000000000..e811b5c71 --- /dev/null +++ b/dist/esm/Page/TextLayer.js @@ -0,0 +1,173 @@ +import _extends from "@babel/runtime/helpers/esm/extends"; +import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck"; +import _createClass from "@babel/runtime/helpers/esm/createClass"; +import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized"; +import _inherits from "@babel/runtime/helpers/esm/inherits"; +import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn"; +import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf"; +import _defineProperty from "@babel/runtime/helpers/esm/defineProperty"; + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +import React, { PureComponent } from 'react'; +import PropTypes from 'prop-types'; +import makeCancellable from 'make-cancellable-promise'; +import invariant from 'tiny-invariant'; +import warning from 'tiny-warning'; +import PageContext from '../PageContext'; +import TextLayerItem from './TextLayerItem'; +import { cancelRunningTask } from '../shared/utils'; +import { isPage, isRotate } from '../shared/propTypes'; +export var TextLayerInternal = /*#__PURE__*/function (_PureComponent) { + _inherits(TextLayerInternal, _PureComponent); + + var _super = _createSuper(TextLayerInternal); + + function TextLayerInternal() { + var _this; + + _classCallCheck(this, TextLayerInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + + _defineProperty(_assertThisInitialized(_this), "state", { + textItems: null + }); + + _defineProperty(_assertThisInitialized(_this), "loadTextItems", function () { + var page = _this.props.page; + var cancellable = makeCancellable(page.getTextContent()); + _this.runningTask = cancellable; + cancellable.promise.then(function (_ref) { + var textItems = _ref.items; + + _this.setState({ + textItems: textItems + }, _this.onLoadSuccess); + })["catch"](function (error) { + _this.onLoadError(error); + }); + }); + + _defineProperty(_assertThisInitialized(_this), "onLoadSuccess", function () { + var onGetTextSuccess = _this.props.onGetTextSuccess; + var textItems = _this.state.textItems; + if (onGetTextSuccess) onGetTextSuccess(textItems); + }); + + _defineProperty(_assertThisInitialized(_this), "onLoadError", function (error) { + _this.setState({ + textItems: false + }); + + warning(error); + var onGetTextError = _this.props.onGetTextError; + if (onGetTextError) onGetTextError(error); + }); + + return _this; + } + + _createClass(TextLayerInternal, [{ + key: "componentDidMount", + value: function componentDidMount() { + var page = this.props.page; + invariant(page, 'Attempted to load page text content, but no page was specified.'); + this.loadTextItems(); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var page = this.props.page; + + if (prevProps.page && page !== prevProps.page) { + this.loadTextItems(); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + cancelRunningTask(this.runningTask); + } + }, { + key: "unrotatedViewport", + get: function get() { + var _this$props = this.props, + page = _this$props.page, + scale = _this$props.scale; + return page.getViewport({ + scale: scale + }); + } + /** + * It might happen that the page is rotated by default. In such cases, we shouldn't rotate + * text content. + */ + + }, { + key: "rotate", + get: function get() { + var _this$props2 = this.props, + page = _this$props2.page, + rotate = _this$props2.rotate; + return rotate - page.rotate; + } + }, { + key: "renderTextItems", + value: function renderTextItems() { + var textItems = this.state.textItems; + + if (!textItems) { + return null; + } + + return textItems.map(function (textItem, itemIndex) { + return /*#__PURE__*/React.createElement(TextLayerItem // eslint-disable-next-line react/no-array-index-key + , _extends({ + key: itemIndex, + itemIndex: itemIndex + }, textItem)); + }); + } + }, { + key: "render", + value: function render() { + var viewport = this.unrotatedViewport, + rotate = this.rotate; + return /*#__PURE__*/React.createElement("div", { + className: "react-pdf__Page__textContent", + style: { + position: 'absolute', + top: '50%', + left: '50%', + width: "".concat(viewport.width, "px"), + height: "".concat(viewport.height, "px"), + color: 'transparent', + transform: "translate(-50%, -50%) rotate(".concat(rotate, "deg)"), + WebkitTransform: "translate(-50%, -50%) rotate(".concat(rotate, "deg)"), + pointerEvents: 'none' + } + }, this.renderTextItems()); + } + }]); + + return TextLayerInternal; +}(PureComponent); +TextLayerInternal.propTypes = { + onGetTextError: PropTypes.func, + onGetTextSuccess: PropTypes.func, + page: isPage.isRequired, + rotate: isRotate, + scale: PropTypes.number +}; +export default function TextLayer(props) { + return /*#__PURE__*/React.createElement(PageContext.Consumer, null, function (context) { + return /*#__PURE__*/React.createElement(TextLayerInternal, _extends({}, context, props)); + }); +} \ No newline at end of file diff --git a/dist/esm/Page/TextLayerItem.js b/dist/esm/Page/TextLayerItem.js new file mode 100644 index 000000000..0d5e02339 --- /dev/null +++ b/dist/esm/Page/TextLayerItem.js @@ -0,0 +1,242 @@ +import _extends from "@babel/runtime/helpers/esm/extends"; +import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray"; +import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck"; +import _createClass from "@babel/runtime/helpers/esm/createClass"; +import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized"; +import _inherits from "@babel/runtime/helpers/esm/inherits"; +import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn"; +import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf"; +import _defineProperty from "@babel/runtime/helpers/esm/defineProperty"; + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +import React, { createRef, PureComponent } from 'react'; +import PropTypes from 'prop-types'; +import PageContext from '../PageContext'; +import { isPage, isRotate } from '../shared/propTypes'; +export var TextLayerItemInternal = /*#__PURE__*/function (_PureComponent) { + _inherits(TextLayerItemInternal, _PureComponent); + + var _super = _createSuper(TextLayerItemInternal); + + function TextLayerItemInternal() { + var _this; + + _classCallCheck(this, TextLayerItemInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + + _defineProperty(_assertThisInitialized(_this), "itemElement", /*#__PURE__*/createRef()); + + _defineProperty(_assertThisInitialized(_this), "getElementWidth", function (element) { + var _assertThisInitialize = _assertThisInitialized(_this), + sideways = _assertThisInitialize.sideways; + + return element.getBoundingClientRect()[sideways ? 'height' : 'width']; + }); + + return _this; + } + + _createClass(TextLayerItemInternal, [{ + key: "componentDidMount", + value: function componentDidMount() { + this.alignTextItem(); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate() { + this.alignTextItem(); + } + }, { + key: "unrotatedViewport", + get: function get() { + var _this$props = this.props, + page = _this$props.page, + scale = _this$props.scale; + return page.getViewport({ + scale: scale + }); + } + /** + * It might happen that the page is rotated by default. In such cases, we shouldn't rotate + * text content. + */ + + }, { + key: "rotate", + get: function get() { + var _this$props2 = this.props, + page = _this$props2.page, + rotate = _this$props2.rotate; + return rotate - page.rotate; + } + }, { + key: "sideways", + get: function get() { + var rotate = this.rotate; + return rotate % 180 !== 0; + } + }, { + key: "defaultSideways", + get: function get() { + var rotation = this.unrotatedViewport.rotation; + return rotation % 180 !== 0; + } + }, { + key: "fontSize", + get: function get() { + var transform = this.props.transform; + var defaultSideways = this.defaultSideways; + + var _transform = _slicedToArray(transform, 2), + fontHeightPx = _transform[0], + fontWidthPx = _transform[1]; + + return defaultSideways ? fontWidthPx : fontHeightPx; + } + }, { + key: "top", + get: function get() { + var transform = this.props.transform; + var viewport = this.unrotatedViewport, + defaultSideways = this.defaultSideways; + + var _transform2 = _slicedToArray(transform, 6), + + /* fontHeightPx */ + + /* fontWidthPx */ + offsetX = _transform2[2], + offsetY = _transform2[3], + x = _transform2[4], + y = _transform2[5]; + + var _viewport$viewBox = _slicedToArray(viewport.viewBox, 4), + + /* xMin */ + yMin + /* xMax */ + = _viewport$viewBox[1], + yMax = _viewport$viewBox[3]; + + return defaultSideways ? x + offsetX + yMin : yMax - (y + offsetY); + } + }, { + key: "left", + get: function get() { + var transform = this.props.transform; + var viewport = this.unrotatedViewport, + defaultSideways = this.defaultSideways; + + var _transform3 = _slicedToArray(transform, 6), + + /* fontHeightPx */ + + /* fontWidthPx */ + + /* offsetX */ + + /* offsetY */ + x = _transform3[4], + y = _transform3[5]; + + var _viewport$viewBox2 = _slicedToArray(viewport.viewBox, 1), + xMin = _viewport$viewBox2[0]; + + return defaultSideways ? y - xMin : x - xMin; + } + }, { + key: "getFontData", + value: function getFontData(fontName) { + var page = this.props.page; + return new Promise(function (resolve) { + page.commonObjs.get(fontName, resolve); + }); + } + }, { + key: "alignTextItem", + value: function alignTextItem() { + var _this2 = this; + + var element = this.itemElement.current; + + if (!element) { + return; + } + + element.style.transform = ''; + var _this$props3 = this.props, + fontName = _this$props3.fontName, + scale = _this$props3.scale, + width = _this$props3.width; + element.style.fontFamily = "".concat(fontName, ", sans-serif"); + this.getFontData(fontName).then(function (fontData) { + var fallbackFontName = fontData ? fontData.fallbackName : 'sans-serif'; + element.style.fontFamily = "".concat(fontName, ", ").concat(fallbackFontName); + var targetWidth = width * scale; + + var actualWidth = _this2.getElementWidth(element); + + var transform = "scaleX(".concat(targetWidth / actualWidth, ")"); + var ascent = fontData ? fontData.ascent : 0; + + if (ascent) { + transform += " translateY(".concat((1 - ascent) * 100, "%)"); + } + + element.style.transform = transform; + element.style.WebkitTransform = transform; + }); + } + }, { + key: "render", + value: function render() { + var fontSize = this.fontSize, + top = this.top, + left = this.left; + var _this$props4 = this.props, + customTextRenderer = _this$props4.customTextRenderer, + scale = _this$props4.scale, + text = _this$props4.str; + return /*#__PURE__*/React.createElement("span", { + ref: this.itemElement, + style: { + height: '1em', + fontFamily: 'sans-serif', + fontSize: "".concat(fontSize * scale, "px"), + position: 'absolute', + top: "".concat(top * scale, "px"), + left: "".concat(left * scale, "px"), + transformOrigin: 'left bottom', + whiteSpace: 'pre', + pointerEvents: 'all' + } + }, customTextRenderer ? customTextRenderer(this.props) : text); + } + }]); + + return TextLayerItemInternal; +}(PureComponent); +TextLayerItemInternal.propTypes = { + customTextRenderer: PropTypes.func, + fontName: PropTypes.string.isRequired, + itemIndex: PropTypes.number.isRequired, + page: isPage.isRequired, + rotate: isRotate, + scale: PropTypes.number, + str: PropTypes.string.isRequired, + transform: PropTypes.arrayOf(PropTypes.number).isRequired, + width: PropTypes.number.isRequired +}; +export default function TextLayerItem(props) { + return /*#__PURE__*/React.createElement(PageContext.Consumer, null, function (context) { + return /*#__PURE__*/React.createElement(TextLayerItemInternal, _extends({}, context, props)); + }); +} \ No newline at end of file diff --git a/dist/esm/PageContext.js b/dist/esm/PageContext.js new file mode 100644 index 000000000..2831aac9e --- /dev/null +++ b/dist/esm/PageContext.js @@ -0,0 +1,2 @@ +import { createContext } from 'react'; +export default /*#__PURE__*/createContext(null); \ No newline at end of file diff --git a/dist/esm/PasswordResponses.js b/dist/esm/PasswordResponses.js new file mode 100644 index 000000000..3c8822dad --- /dev/null +++ b/dist/esm/PasswordResponses.js @@ -0,0 +1,6 @@ +// As defined in https://github.com/mozilla/pdf.js/blob/d9fac3459609a807be6506fb3441b5da4b154d14/src/shared/util.js#L371-L374 +var PasswordResponses = { + NEED_PASSWORD: 1, + INCORRECT_PASSWORD: 2 +}; +export default PasswordResponses; \ No newline at end of file diff --git a/dist/esm/Ref.js b/dist/esm/Ref.js new file mode 100644 index 000000000..2ce4ec99a --- /dev/null +++ b/dist/esm/Ref.js @@ -0,0 +1,31 @@ +import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck"; +import _createClass from "@babel/runtime/helpers/esm/createClass"; + +var Ref = /*#__PURE__*/function () { + function Ref(_ref) { + var num = _ref.num, + gen = _ref.gen; + + _classCallCheck(this, Ref); + + this.num = num; + this.gen = gen; + } + + _createClass(Ref, [{ + key: "toString", + value: function toString() { + var str = "".concat(this.num, "R"); + + if (this.gen !== 0) { + str += this.gen; + } + + return str; + } + }]); + + return Ref; +}(); + +export { Ref as default }; \ No newline at end of file diff --git a/dist/esm/entry.jest.js b/dist/esm/entry.jest.js new file mode 100644 index 000000000..a2b5c559c --- /dev/null +++ b/dist/esm/entry.jest.js @@ -0,0 +1,6 @@ +import * as pdfjs from 'pdfjs-dist/legacy/build/pdf'; +import Document from './Document'; +import Outline from './Outline'; +import Page from './Page'; +import './pdf.worker.entry'; +export { pdfjs, Document, Outline, Page }; \ No newline at end of file diff --git a/dist/esm/entry.js b/dist/esm/entry.js new file mode 100644 index 000000000..42e631248 --- /dev/null +++ b/dist/esm/entry.js @@ -0,0 +1,8 @@ +import * as pdfjs from 'pdfjs-dist/legacy/build/pdf'; +import Document from './Document'; +import Outline from './Outline'; +import Page from './Page'; +import { displayWorkerWarning } from './shared/utils'; +displayWorkerWarning(); +pdfjs.GlobalWorkerOptions.workerSrc = 'pdf.worker.js'; +export { pdfjs, Document, Outline, Page }; \ No newline at end of file diff --git a/dist/esm/entry.parcel.js b/dist/esm/entry.parcel.js new file mode 100644 index 000000000..d2d893704 --- /dev/null +++ b/dist/esm/entry.parcel.js @@ -0,0 +1,12 @@ +import * as pdfjs from 'pdfjs-dist/legacy/build/pdf'; +import Document from './Document'; +import Outline from './Outline'; +import Page from './Page'; +import { displayWorkerWarning } from './shared/utils'; +displayWorkerWarning(); + +if (typeof window !== 'undefined' && 'Worker' in window) { + pdfjs.GlobalWorkerOptions.workerPort = new Worker('./pdf.worker.entry.js'); +} + +export { pdfjs, Document, Outline, Page }; \ No newline at end of file diff --git a/dist/esm/entry.parcel2.js b/dist/esm/entry.parcel2.js new file mode 100644 index 000000000..69afed509 --- /dev/null +++ b/dist/esm/entry.parcel2.js @@ -0,0 +1,14 @@ +import * as pdfjs from 'pdfjs-dist/legacy/build/pdf'; +import Document from './Document'; +import Outline from './Outline'; +import Page from './Page'; +import { displayWorkerWarning } from './shared/utils'; +displayWorkerWarning(); + +if (typeof window !== 'undefined' && 'Worker' in window) { + pdfjs.GlobalWorkerOptions.workerPort = new Worker(new URL('./pdf.worker.entry.js', import.meta.url), { + type: 'module' + }); +} + +export { pdfjs, Document, Outline, Page }; \ No newline at end of file diff --git a/dist/esm/entry.webpack.js b/dist/esm/entry.webpack.js new file mode 100644 index 000000000..bd0dfed3c --- /dev/null +++ b/dist/esm/entry.webpack.js @@ -0,0 +1,10 @@ +import * as pdfjs from 'pdfjs-dist/legacy/build/pdf'; // eslint-disable-next-line import/no-unresolved + +import pdfjsWorker from 'file-loader!pdfjs-dist/legacy/build/pdf.worker'; +import Document from './Document'; +import Outline from './Outline'; +import Page from './Page'; +import { displayWorkerWarning } from './shared/utils'; +displayWorkerWarning(); +pdfjs.GlobalWorkerOptions.workerSrc = pdfjsWorker; +export { pdfjs, Document, Outline, Page }; \ No newline at end of file diff --git a/dist/esm/entry.webpack5.js b/dist/esm/entry.webpack5.js new file mode 100644 index 000000000..9843b9602 --- /dev/null +++ b/dist/esm/entry.webpack5.js @@ -0,0 +1,8 @@ +import * as pdfjs from 'pdfjs-dist/legacy/build/pdf'; +import Document from './Document'; +import Outline from './Outline'; +import Page from './Page'; +import { displayWorkerWarning } from './shared/utils'; +displayWorkerWarning(); +pdfjs.GlobalWorkerOptions.workerSrc = new URL('pdfjs-dist/legacy/build/pdf.worker', import.meta.url); +export { pdfjs, Document, Outline, Page }; \ No newline at end of file diff --git a/dist/esm/pdf.worker.entry.js b/dist/esm/pdf.worker.entry.js new file mode 100644 index 000000000..808cee176 --- /dev/null +++ b/dist/esm/pdf.worker.entry.js @@ -0,0 +1,7 @@ +/** + * PDF.js worker entry file. + * + * This file is identical to Mozilla's pdf.worker.entry.js, with one exception being placed inside + * this bundle, not theirs. + */ +(typeof window !== 'undefined' ? window : {}).pdfjsWorker = require('pdfjs-dist/legacy/build/pdf.worker'); \ No newline at end of file diff --git a/dist/esm/shared/propTypes.js b/dist/esm/shared/propTypes.js new file mode 100644 index 000000000..c6c29f499 --- /dev/null +++ b/dist/esm/shared/propTypes.js @@ -0,0 +1,116 @@ +import _typeof from "@babel/runtime/helpers/esm/typeof"; +import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray"; +import PropTypes from 'prop-types'; +import { mouseEvents, touchEvents, keyboardEvents } from 'make-event-props'; +import { isDefined } from './utils'; +import LinkService from '../LinkService'; +export var eventProps = function () { + var result = {}; + [].concat(_toConsumableArray(mouseEvents), _toConsumableArray(touchEvents), _toConsumableArray(keyboardEvents)).forEach(function (eventName) { + result[eventName] = PropTypes.func; + }); + return result; +}(); +var fileTypes = [PropTypes.string, PropTypes.instanceOf(ArrayBuffer), PropTypes.shape({ + data: PropTypes.oneOfType([PropTypes.object, PropTypes.string]), + httpHeaders: PropTypes.object, + range: PropTypes.object, + url: PropTypes.string, + withCredentials: PropTypes.bool +})]; + +if (typeof File !== 'undefined') { + fileTypes.push(PropTypes.instanceOf(File)); +} + +if (typeof Blob !== 'undefined') { + fileTypes.push(PropTypes.instanceOf(Blob)); +} + +export var isClassName = PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.string)]); +export var isFile = PropTypes.oneOfType(fileTypes); +export var isLinkService = PropTypes.instanceOf(LinkService); +export var isLinkTarget = PropTypes.oneOf(['_self', '_blank', '_parent', '_top']); +export var isPage = PropTypes.shape({ + _transport: PropTypes.shape({ + fontLoader: PropTypes.object.isRequired + }).isRequired, + commonObjs: PropTypes.shape({ + _objs: PropTypes.object.isRequired + }).isRequired, + getAnnotations: PropTypes.func.isRequired, + getTextContent: PropTypes.func.isRequired, + getViewport: PropTypes.func.isRequired, + render: PropTypes.func.isRequired +}); +export var isPageIndex = function isPageIndex(props, propName, componentName) { + var pageIndex = props[propName], + pageNumber = props.pageNumber, + pdf = props.pdf; + + if (!isDefined(pdf)) { + return null; + } + + if (isDefined(pageIndex)) { + if (typeof pageIndex !== 'number') { + return new Error("`".concat(propName, "` of type `").concat(_typeof(pageIndex), "` supplied to `").concat(componentName, "`, expected `number`.")); + } + + if (pageIndex < 0) { + return new Error("Expected `".concat(propName, "` to be greater or equal to 0.")); + } + + var numPages = pdf.numPages; + + if (pageIndex + 1 > numPages) { + return new Error("Expected `".concat(propName, "` to be less or equal to ").concat(numPages - 1, ".")); + } + } else if (!isDefined(pageNumber)) { + return new Error("`".concat(propName, "` not supplied. Either pageIndex or pageNumber must be supplied to `").concat(componentName, "`.")); + } // Everything is fine + + + return null; +}; +export var isPageNumber = function isPageNumber(props, propName, componentName) { + var pageNumber = props[propName], + pageIndex = props.pageIndex, + pdf = props.pdf; + + if (!isDefined(pdf)) { + return null; + } + + if (isDefined(pageNumber)) { + if (typeof pageNumber !== 'number') { + return new Error("`".concat(propName, "` of type `").concat(_typeof(pageNumber), "` supplied to `").concat(componentName, "`, expected `number`.")); + } + + if (pageNumber < 1) { + return new Error("Expected `".concat(propName, "` to be greater or equal to 1.")); + } + + var numPages = pdf.numPages; + + if (pageNumber > numPages) { + return new Error("Expected `".concat(propName, "` to be less or equal to ").concat(numPages, ".")); + } + } else if (!isDefined(pageIndex)) { + return new Error("`".concat(propName, "` not supplied. Either pageIndex or pageNumber must be supplied to `").concat(componentName, "`.")); + } // Everything is fine + + + return null; +}; +export var isPdf = PropTypes.oneOfType([PropTypes.shape({ + getDestination: PropTypes.func.isRequired, + getOutline: PropTypes.func.isRequired, + getPage: PropTypes.func.isRequired, + numPages: PropTypes.number.isRequired +}), PropTypes.bool]); +export var isRef = PropTypes.oneOfType([PropTypes.func, PropTypes.shape({ + current: PropTypes.any +})]); +export var isRenderMode = PropTypes.oneOf(['canvas', 'none', 'svg']); +export var isRotate = PropTypes.oneOf([0, 90, 180, 270]); \ No newline at end of file diff --git a/dist/esm/shared/utils.js b/dist/esm/shared/utils.js new file mode 100644 index 000000000..b2bc9fb8a --- /dev/null +++ b/dist/esm/shared/utils.js @@ -0,0 +1,168 @@ +import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray"; +import invariant from 'tiny-invariant'; +import warning from 'tiny-warning'; +/** + * Checks if we're running in a browser environment. + */ + +export var isBrowser = typeof window !== 'undefined'; +/** + * Checks whether we're running from a local file system. + */ + +export var isLocalFileSystem = isBrowser && window.location.protocol === 'file:'; +/** + * Checks whether a variable is defined. + * + * @param {*} variable Variable to check + */ + +export function isDefined(variable) { + return typeof variable !== 'undefined'; +} +/** + * Checks whether a variable is defined and not null. + * + * @param {*} variable Variable to check + */ + +export function isProvided(variable) { + return isDefined(variable) && variable !== null; +} +/** + * Checkes whether a variable provided is a string. + * + * @param {*} variable Variable to check + */ + +export function isString(variable) { + return typeof variable === 'string'; +} +/** + * Checks whether a variable provided is an ArrayBuffer. + * + * @param {*} variable Variable to check + */ + +export function isArrayBuffer(variable) { + return variable instanceof ArrayBuffer; +} +/** + * Checkes whether a variable provided is a Blob. + * + * @param {*} variable Variable to check + */ + +export function isBlob(variable) { + invariant(isBrowser, 'isBlob can only be used in a browser environment'); + return variable instanceof Blob; +} +/** + * Checkes whether a variable provided is a File. + * + * @param {*} variable Variable to check + */ + +export function isFile(variable) { + invariant(isBrowser, 'isFile can only be used in a browser environment'); + return variable instanceof File; +} +/** + * Checks whether a string provided is a data URI. + * + * @param {string} str String to check + */ + +export function isDataURI(str) { + return isString(str) && /^data:/.test(str); +} +export function dataURItoByteString(dataURI) { + invariant(isDataURI(dataURI), 'Invalid data URI.'); + + var _dataURI$split = dataURI.split(','), + _dataURI$split2 = _slicedToArray(_dataURI$split, 2), + headersString = _dataURI$split2[0], + dataString = _dataURI$split2[1]; + + var headers = headersString.split(';'); + + if (headers.indexOf('base64') !== -1) { + return atob(dataString); + } + + return unescape(dataString); +} +export function getPixelRatio() { + return isBrowser && window.devicePixelRatio || 1; +} +var allowFileAccessFromFilesTip = 'On Chromium based browsers, you can use --allow-file-access-from-files flag for debugging purposes.'; +export function displayCORSWarning() { + warning(!isLocalFileSystem, "Loading PDF as base64 strings/URLs may not work on protocols other than HTTP/HTTPS. ".concat(allowFileAccessFromFilesTip)); +} +export function displayWorkerWarning() { + warning(!isLocalFileSystem, "Loading PDF.js worker may not work on protocols other than HTTP/HTTPS. ".concat(allowFileAccessFromFilesTip)); +} +export function cancelRunningTask(runningTask) { + if (runningTask && runningTask.cancel) runningTask.cancel(); +} +export function makePageCallback(page, scale) { + Object.defineProperty(page, 'width', { + get: function get() { + return this.view[2] * scale; + }, + configurable: true + }); + Object.defineProperty(page, 'height', { + get: function get() { + return this.view[3] * scale; + }, + configurable: true + }); + Object.defineProperty(page, 'originalWidth', { + get: function get() { + return this.view[2]; + }, + configurable: true + }); + Object.defineProperty(page, 'originalHeight', { + get: function get() { + return this.view[3]; + }, + configurable: true + }); + return page; +} +export function isCancelException(error) { + return error.name === 'RenderingCancelledException'; +} +export function loadFromFile(file) { + return new Promise(function (resolve, reject) { + var reader = new FileReader(); + + reader.onload = function () { + return resolve(new Uint8Array(reader.result)); + }; + + reader.onerror = function (event) { + switch (event.target.error.code) { + case event.target.error.NOT_FOUND_ERR: + return reject(new Error('Error while reading a file: File not found.')); + + case event.target.error.NOT_READABLE_ERR: + return reject(new Error('Error while reading a file: File not readable.')); + + case event.target.error.SECURITY_ERR: + return reject(new Error('Error while reading a file: Security error.')); + + case event.target.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); + return null; + }); +} \ No newline at end of file diff --git a/dist/umd/Document.js b/dist/umd/Document.js new file mode 100644 index 000000000..fc97d04d7 --- /dev/null +++ b/dist/umd/Document.js @@ -0,0 +1,461 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +var _typeof3 = require("@babel/runtime/helpers/typeof"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends")); + +var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties")); + +var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof")); + +var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck")); + +var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass")); + +var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized")); + +var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits")); + +var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn")); + +var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf")); + +var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty")); + +var _react = _interopRequireWildcard(require("react")); + +var _propTypes = _interopRequireDefault(require("prop-types")); + +var _makeEventProps = _interopRequireDefault(require("make-event-props")); + +var _makeCancellablePromise = _interopRequireDefault(require("make-cancellable-promise")); + +var _mergeClassNames = _interopRequireDefault(require("merge-class-names")); + +var _tinyInvariant = _interopRequireDefault(require("tiny-invariant")); + +var _tinyWarning = _interopRequireDefault(require("tiny-warning")); + +var pdfjs = _interopRequireWildcard(require("pdfjs-dist/legacy/build/pdf")); + +var _DocumentContext = _interopRequireDefault(require("./DocumentContext")); + +var _Message = _interopRequireDefault(require("./Message")); + +var _LinkService = _interopRequireDefault(require("./LinkService")); + +var _PasswordResponses = _interopRequireDefault(require("./PasswordResponses")); + +var _utils = require("./shared/utils"); + +var _propTypes2 = require("./shared/propTypes"); + +var _excluded = ["url"]; + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof3(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +var PDFDataRangeTransport = pdfjs.PDFDataRangeTransport; + +var Document = /*#__PURE__*/function (_PureComponent) { + (0, _inherits2["default"])(Document, _PureComponent); + + var _super = _createSuper(Document); + + function Document() { + var _this; + + (0, _classCallCheck2["default"])(this, Document); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "state", { + pdf: null + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "viewer", { + scrollPageIntoView: function scrollPageIntoView(_ref) { + var dest = _ref.dest, + pageIndex = _ref.pageIndex, + pageNumber = _ref.pageNumber; + // Handling jumping to internal links target + var onItemClick = _this.props.onItemClick; // First, check if custom handling of onItemClick was provided + + if (onItemClick) { + onItemClick({ + dest: dest, + pageIndex: pageIndex, + pageNumber: pageNumber + }); + return; + } // If not, try to look for target page within the . + + + var page = _this.pages[pageIndex]; + + if (page) { + // Scroll to the page automatically + page.scrollIntoView(); + return; + } + + (0, _tinyWarning["default"])(false, "An internal link leading to page ".concat(pageNumber, " was clicked, but neither was provided with onItemClick nor it was able to find the page within itself. Either provide onItemClick to and handle navigating by yourself or ensure that all pages are rendered within .")); + } + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "linkService", new _LinkService["default"]()); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "loadDocument", function () { + // If another rendering is in progress, let's cancel it + (0, _utils.cancelRunningTask)(_this.runningTask); // If another loading is in progress, let's destroy it + + if (_this.loadingTask) _this.loadingTask.destroy(); + var cancellable = (0, _makeCancellablePromise["default"])(_this.findDocumentSource()); + _this.runningTask = cancellable; + cancellable.promise.then(function (source) { + _this.onSourceSuccess(); + + if (!source) { + return; + } + + _this.setState(function (prevState) { + if (!prevState.pdf) { + return null; + } + + return { + pdf: null + }; + }); + + var _this$props = _this.props, + options = _this$props.options, + onLoadProgress = _this$props.onLoadProgress, + onPassword = _this$props.onPassword; + _this.loadingTask = pdfjs.getDocument(_objectSpread(_objectSpread(_objectSpread({}, source), options), {}, { + isEvalSupported: false + })); + _this.loadingTask.onPassword = onPassword; + + if (onLoadProgress) { + _this.loadingTask.onProgress = onLoadProgress; + } + + var cancellable = (0, _makeCancellablePromise["default"])(_this.loadingTask.promise); + _this.runningTask = cancellable; + cancellable.promise.then(function (pdf) { + _this.setState(function (prevState) { + if (prevState.pdf && prevState.pdf.fingerprint === pdf.fingerprint) { + return null; + } + + return { + pdf: pdf + }; + }, _this.onLoadSuccess); + })["catch"](function (error) { + _this.onLoadError(error); + }); + })["catch"](function (error) { + _this.onSourceError(error); + }); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "setupLinkService", function () { + var _this$props2 = _this.props, + externalLinkRel = _this$props2.externalLinkRel, + externalLinkTarget = _this$props2.externalLinkTarget; + + _this.linkService.setViewer(_this.viewer); + + _this.linkService.setExternalLinkRel(externalLinkRel); + + _this.linkService.setExternalLinkTarget(externalLinkTarget); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onSourceSuccess", function () { + var onSourceSuccess = _this.props.onSourceSuccess; + if (onSourceSuccess) onSourceSuccess(); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onSourceError", function (error) { + (0, _tinyWarning["default"])(error); + var onSourceError = _this.props.onSourceError; + if (onSourceError) onSourceError(error); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onLoadSuccess", function () { + var onLoadSuccess = _this.props.onLoadSuccess; + var pdf = _this.state.pdf; + if (onLoadSuccess) onLoadSuccess(pdf); + _this.pages = new Array(pdf.numPages); + + _this.linkService.setDocument(pdf); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onLoadError", function (error) { + _this.setState({ + pdf: false + }); + + (0, _tinyWarning["default"])(error); + var onLoadError = _this.props.onLoadError; + if (onLoadError) onLoadError(error); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "findDocumentSource", function () { + return new Promise(function (resolve) { + var file = _this.props.file; + + if (!file) { + resolve(null); + } // File is a string + + + if (typeof file === 'string') { + if ((0, _utils.isDataURI)(file)) { + var fileByteString = (0, _utils.dataURItoByteString)(file); + resolve({ + data: fileByteString + }); + } + + (0, _utils.displayCORSWarning)(); + resolve({ + url: file + }); + } // File is PDFDataRangeTransport + + + if (file instanceof PDFDataRangeTransport) { + resolve({ + range: file + }); + } // File is an ArrayBuffer + + + if ((0, _utils.isArrayBuffer)(file)) { + resolve({ + data: file + }); + } + /** + * The cases below are browser-only. + * If you're running on a non-browser environment, these cases will be of no use. + */ + + + if (_utils.isBrowser) { + // File is a Blob + if ((0, _utils.isBlob)(file) || (0, _utils.isFile)(file)) { + (0, _utils.loadFromFile)(file).then(function (data) { + resolve({ + data: data + }); + }); + return; + } + } // At this point, file must be an object + + + (0, _tinyInvariant["default"])((0, _typeof2["default"])(file) === 'object', 'Invalid parameter in file, need either Uint8Array, string or a parameter object'); + (0, _tinyInvariant["default"])(file.url || file.data || file.range, 'Invalid parameter object: need either .data, .range or .url'); // File .url is a string + + if (typeof file.url === 'string') { + if ((0, _utils.isDataURI)(file.url)) { + var url = file.url, + otherParams = (0, _objectWithoutProperties2["default"])(file, _excluded); + + var _fileByteString = (0, _utils.dataURItoByteString)(url); + + resolve(_objectSpread({ + data: _fileByteString + }, otherParams)); + } + + (0, _utils.displayCORSWarning)(); + } + + resolve(file); + }); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "registerPage", function (pageIndex, ref) { + _this.pages[pageIndex] = ref; + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "unregisterPage", function (pageIndex) { + delete _this.pages[pageIndex]; + }); + return _this; + } + + (0, _createClass2["default"])(Document, [{ + key: "componentDidMount", + value: function componentDidMount() { + this.loadDocument(); + this.setupLinkService(); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var file = this.props.file; + + if (file !== prevProps.file) { + this.loadDocument(); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + // If rendering is in progress, let's cancel it + (0, _utils.cancelRunningTask)(this.runningTask); // If loading is in progress, let's destroy it + + if (this.loadingTask) this.loadingTask.destroy(); + } + }, { + key: "childContext", + get: function get() { + var linkService = this.linkService, + registerPage = this.registerPage, + unregisterPage = this.unregisterPage; + var _this$props3 = this.props, + imageResourcesPath = _this$props3.imageResourcesPath, + renderMode = _this$props3.renderMode, + rotate = _this$props3.rotate; + var pdf = this.state.pdf; + return { + imageResourcesPath: imageResourcesPath, + linkService: linkService, + pdf: pdf, + registerPage: registerPage, + renderMode: renderMode, + rotate: rotate, + unregisterPage: unregisterPage + }; + } + }, { + key: "eventProps", + get: function get() { + var _this2 = this; + + return (0, _makeEventProps["default"])(this.props, function () { + return _this2.state.pdf; + }); + } + /** + * Called when a document source is resolved correctly + */ + + }, { + key: "renderChildren", + value: function renderChildren() { + var children = this.props.children; + return /*#__PURE__*/_react["default"].createElement(_DocumentContext["default"].Provider, { + value: this.childContext + }, children); + } + }, { + key: "renderContent", + value: function renderContent() { + var file = this.props.file; + var pdf = this.state.pdf; + + if (!file) { + var noData = this.props.noData; + return /*#__PURE__*/_react["default"].createElement(_Message["default"], { + type: "no-data" + }, typeof noData === 'function' ? noData() : noData); + } + + if (pdf === null) { + var loading = this.props.loading; + return /*#__PURE__*/_react["default"].createElement(_Message["default"], { + type: "loading" + }, typeof loading === 'function' ? loading() : loading); + } + + if (pdf === false) { + var error = this.props.error; + return /*#__PURE__*/_react["default"].createElement(_Message["default"], { + type: "error" + }, typeof error === 'function' ? error() : error); + } + + return this.renderChildren(); + } + }, { + key: "render", + value: function render() { + var _this$props4 = this.props, + className = _this$props4.className, + inputRef = _this$props4.inputRef; + return /*#__PURE__*/_react["default"].createElement("div", (0, _extends2["default"])({ + className: (0, _mergeClassNames["default"])('react-pdf__Document', className), + ref: inputRef + }, this.eventProps), this.renderContent()); + } + }]); + return Document; +}(_react.PureComponent); + +exports["default"] = Document; +Document.defaultProps = { + error: 'Failed to load PDF file.', + loading: 'Loading PDF…', + noData: 'No PDF file specified.', + onPassword: function onPassword(callback, reason) { + switch (reason) { + case _PasswordResponses["default"].NEED_PASSWORD: + { + // eslint-disable-next-line no-alert + var password = prompt('Enter the password to open this PDF file.'); + callback(password); + break; + } + + case _PasswordResponses["default"].INCORRECT_PASSWORD: + { + // eslint-disable-next-line no-alert + var _password = prompt('Invalid password. Please try again.'); + + callback(_password); + break; + } + + default: + } + } +}; + +var isFunctionOrNode = _propTypes["default"].oneOfType([_propTypes["default"].func, _propTypes["default"].node]); + +Document.propTypes = _objectSpread(_objectSpread({}, _propTypes2.eventProps), {}, { + children: _propTypes["default"].node, + className: _propTypes2.isClassName, + error: isFunctionOrNode, + externalLinkRel: _propTypes["default"].string, + externalLinkTarget: _propTypes["default"].string, + file: _propTypes2.isFile, + imageResourcesPath: _propTypes["default"].string, + inputRef: _propTypes2.isRef, + loading: isFunctionOrNode, + noData: isFunctionOrNode, + onItemClick: _propTypes["default"].func, + onLoadError: _propTypes["default"].func, + onLoadProgress: _propTypes["default"].func, + onLoadSuccess: _propTypes["default"].func, + onPassword: _propTypes["default"].func, + onSourceError: _propTypes["default"].func, + onSourceSuccess: _propTypes["default"].func, + rotate: _propTypes["default"].number +}); \ No newline at end of file diff --git a/dist/umd/DocumentContext.js b/dist/umd/DocumentContext.js new file mode 100644 index 000000000..8ad6269bd --- /dev/null +++ b/dist/umd/DocumentContext.js @@ -0,0 +1,12 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _react = require("react"); + +var _default = /*#__PURE__*/(0, _react.createContext)(null); + +exports["default"] = _default; \ No newline at end of file diff --git a/dist/umd/LinkService.js b/dist/umd/LinkService.js new file mode 100644 index 000000000..8db9e0961 --- /dev/null +++ b/dist/umd/LinkService.js @@ -0,0 +1,169 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck")); + +var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass")); + +var _tinyInvariant = _interopRequireDefault(require("tiny-invariant")); + +/* Copyright 2015 Mozilla Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +var DEFAULT_LINK_REL = 'noopener noreferrer nofollow'; + +var LinkService = /*#__PURE__*/function () { + function LinkService() { + (0, _classCallCheck2["default"])(this, LinkService); + this.externalLinkTarget = null; + this.externalLinkRel = null; + } + + (0, _createClass2["default"])(LinkService, [{ + key: "setDocument", + value: function setDocument(pdfDocument) { + this.pdfDocument = pdfDocument; + } + }, { + key: "setViewer", + value: function setViewer(pdfViewer) { + this.pdfViewer = pdfViewer; + } + }, { + key: "setExternalLinkRel", + value: function setExternalLinkRel(externalLinkRel) { + this.externalLinkRel = externalLinkRel; + } + }, { + key: "setExternalLinkTarget", + value: function setExternalLinkTarget(externalLinkTarget) { + this.externalLinkTarget = externalLinkTarget; + } + }, { + key: "setHistory", + value: function setHistory() {} + }, { + key: "pagesCount", + get: function get() { + return this.pdfDocument ? this.pdfDocument.numPages : 0; + } + }, { + key: "page", + get: function get() { + return this.pdfViewer.currentPageNumber; + }, + set: function set(value) { + this.pdfViewer.currentPageNumber = value; + } + }, { + key: "rotation", + get: function get() { + return 0; + }, + set: function set(value) {} + }, { + key: "goToDestination", + value: function goToDestination(dest) { + var _this = this; + + new Promise(function (resolve) { + if (typeof dest === 'string') { + _this.pdfDocument.getDestination(dest).then(resolve); + } else if (Array.isArray(dest)) { + resolve(dest); + } else { + dest.then(resolve); + } + }).then(function (explicitDest) { + (0, _tinyInvariant["default"])(Array.isArray(explicitDest), "\"".concat(explicitDest, "\" is not a valid destination array.")); + var destRef = explicitDest[0]; + new Promise(function (resolve) { + if (destRef instanceof Object) { + _this.pdfDocument.getPageIndex(destRef).then(function (pageIndex) { + resolve(pageIndex); + })["catch"](function () { + (0, _tinyInvariant["default"])(false, "\"".concat(destRef, "\" is not a valid page reference.")); + }); + } else if (typeof destRef === 'number') { + resolve(destRef); + } else { + (0, _tinyInvariant["default"])(false, "\"".concat(destRef, "\" is not a valid destination reference.")); + } + }).then(function (pageIndex) { + var pageNumber = pageIndex + 1; + (0, _tinyInvariant["default"])(pageNumber >= 1 && pageNumber <= _this.pagesCount, "\"".concat(pageNumber, "\" is not a valid page number.")); + + _this.pdfViewer.scrollPageIntoView({ + dest: dest, + pageIndex: pageIndex, + pageNumber: pageNumber + }); + }); + }); + } + }, { + key: "navigateTo", + value: function navigateTo(dest) { + this.goToDestination(dest); + } + }, { + key: "goToPage", + value: function goToPage() {} + }, { + key: "addLinkAttributes", + value: function addLinkAttributes(link, url, newWindow) { + link.href = url; + link.rel = this.externalLinkRel || DEFAULT_LINK_REL; + link.target = newWindow ? '_blank' : this.externalLinkTarget || ''; + } + }, { + key: "getDestinationHash", + value: function getDestinationHash() { + return '#'; + } + }, { + key: "getAnchorUrl", + value: function getAnchorUrl() { + return '#'; + } + }, { + key: "setHash", + value: function setHash() {} + }, { + key: "executeNamedAction", + value: function executeNamedAction() {} + }, { + key: "cachePageRef", + value: function cachePageRef() {} + }, { + key: "isPageVisible", + value: function isPageVisible() { + return true; + } + }, { + key: "isPageCached", + value: function isPageCached() { + return true; + } + }]); + return LinkService; +}(); + +exports["default"] = LinkService; \ No newline at end of file diff --git a/dist/umd/Message.js b/dist/umd/Message.js new file mode 100644 index 000000000..47cfc2016 --- /dev/null +++ b/dist/umd/Message.js @@ -0,0 +1,25 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = Message; + +var _react = _interopRequireDefault(require("react")); + +var _propTypes = _interopRequireDefault(require("prop-types")); + +function Message(_ref) { + var children = _ref.children, + type = _ref.type; + return /*#__PURE__*/_react["default"].createElement("div", { + className: "react-pdf__message react-pdf__message--".concat(type) + }, children); +} + +Message.propTypes = { + children: _propTypes["default"].node, + type: _propTypes["default"].oneOf(['error', 'loading', 'no-data']).isRequired +}; \ No newline at end of file diff --git a/dist/umd/Outline.js b/dist/umd/Outline.js new file mode 100644 index 000000000..b0e30cb81 --- /dev/null +++ b/dist/umd/Outline.js @@ -0,0 +1,232 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +var _typeof = require("@babel/runtime/helpers/typeof"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = exports.OutlineInternal = void 0; + +var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends")); + +var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck")); + +var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass")); + +var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized")); + +var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits")); + +var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn")); + +var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf")); + +var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty")); + +var _react = _interopRequireWildcard(require("react")); + +var _propTypes = _interopRequireDefault(require("prop-types")); + +var _makeCancellablePromise = _interopRequireDefault(require("make-cancellable-promise")); + +var _makeEventProps = _interopRequireDefault(require("make-event-props")); + +var _mergeClassNames = _interopRequireDefault(require("merge-class-names")); + +var _tinyInvariant = _interopRequireDefault(require("tiny-invariant")); + +var _tinyWarning = _interopRequireDefault(require("tiny-warning")); + +var _DocumentContext = _interopRequireDefault(require("./DocumentContext")); + +var _OutlineContext = _interopRequireDefault(require("./OutlineContext")); + +var _OutlineItem = _interopRequireDefault(require("./OutlineItem")); + +var _utils = require("./shared/utils"); + +var _propTypes2 = require("./shared/propTypes"); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +var OutlineInternal = /*#__PURE__*/function (_PureComponent) { + (0, _inherits2["default"])(OutlineInternal, _PureComponent); + + var _super = _createSuper(OutlineInternal); + + function OutlineInternal() { + var _this; + + (0, _classCallCheck2["default"])(this, OutlineInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "state", { + outline: null + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "loadOutline", function () { + var pdf = _this.props.pdf; + + _this.setState(function (prevState) { + if (!prevState.outline) { + return null; + } + + return { + outline: null + }; + }); + + var cancellable = (0, _makeCancellablePromise["default"])(pdf.getOutline()); + _this.runningTask = cancellable; + cancellable.promise.then(function (outline) { + _this.setState({ + outline: outline + }, _this.onLoadSuccess); + })["catch"](function (error) { + _this.onLoadError(error); + }); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onLoadSuccess", function () { + var onLoadSuccess = _this.props.onLoadSuccess; + var outline = _this.state.outline; + if (onLoadSuccess) onLoadSuccess(outline); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onLoadError", function (error) { + _this.setState({ + outline: false + }); + + (0, _tinyWarning["default"])(error); + var onLoadError = _this.props.onLoadError; + if (onLoadError) onLoadError(error); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onItemClick", function (_ref) { + var dest = _ref.dest, + pageIndex = _ref.pageIndex, + pageNumber = _ref.pageNumber; + var onItemClick = _this.props.onItemClick; + + if (onItemClick) { + onItemClick({ + dest: dest, + pageIndex: pageIndex, + pageNumber: pageNumber + }); + } + }); + return _this; + } + + (0, _createClass2["default"])(OutlineInternal, [{ + key: "componentDidMount", + value: function componentDidMount() { + var pdf = this.props.pdf; + (0, _tinyInvariant["default"])(pdf, 'Attempted to load an outline, but no document was specified.'); + this.loadOutline(); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var pdf = this.props.pdf; + + if (prevProps.pdf && pdf !== prevProps.pdf) { + this.loadOutline(); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + (0, _utils.cancelRunningTask)(this.runningTask); + } + }, { + key: "childContext", + get: function get() { + return { + onClick: this.onItemClick + }; + } + }, { + key: "eventProps", + get: function get() { + var _this2 = this; + + return (0, _makeEventProps["default"])(this.props, function () { + return _this2.state.outline; + }); + } + /** + * Called when an outline is read successfully + */ + + }, { + key: "renderOutline", + value: function renderOutline() { + var outline = this.state.outline; + return /*#__PURE__*/_react["default"].createElement("ul", null, outline.map(function (item, itemIndex) { + return /*#__PURE__*/_react["default"].createElement(_OutlineItem["default"], { + key: typeof item.destination === 'string' ? item.destination : itemIndex, + item: item + }); + })); + } + }, { + key: "render", + value: function render() { + var pdf = this.props.pdf; + var outline = this.state.outline; + + if (!pdf || !outline) { + return null; + } + + var _this$props = this.props, + className = _this$props.className, + inputRef = _this$props.inputRef; + return /*#__PURE__*/_react["default"].createElement("div", (0, _extends2["default"])({ + className: (0, _mergeClassNames["default"])('react-pdf__Outline', className), + ref: inputRef + }, this.eventProps), /*#__PURE__*/_react["default"].createElement(_OutlineContext["default"].Provider, { + value: this.childContext + }, this.renderOutline())); + } + }]); + return OutlineInternal; +}(_react.PureComponent); + +exports.OutlineInternal = OutlineInternal; +OutlineInternal.propTypes = _objectSpread({ + className: _propTypes2.isClassName, + inputRef: _propTypes2.isRef, + onItemClick: _propTypes["default"].func, + onLoadError: _propTypes["default"].func, + onLoadSuccess: _propTypes["default"].func, + pdf: _propTypes2.isPdf +}, _propTypes2.eventProps); + +function Outline(props, ref) { + return /*#__PURE__*/_react["default"].createElement(_DocumentContext["default"].Consumer, null, function (context) { + return /*#__PURE__*/_react["default"].createElement(OutlineInternal, (0, _extends2["default"])({ + ref: ref + }, context, props)); + }); +} + +var _default = /*#__PURE__*/_react["default"].forwardRef(Outline); + +exports["default"] = _default; \ No newline at end of file diff --git a/dist/umd/OutlineContext.js b/dist/umd/OutlineContext.js new file mode 100644 index 000000000..8ad6269bd --- /dev/null +++ b/dist/umd/OutlineContext.js @@ -0,0 +1,12 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _react = require("react"); + +var _default = /*#__PURE__*/(0, _react.createContext)(null); + +exports["default"] = _default; \ No newline at end of file diff --git a/dist/umd/OutlineItem.js b/dist/umd/OutlineItem.js new file mode 100644 index 000000000..43446ddc0 --- /dev/null +++ b/dist/umd/OutlineItem.js @@ -0,0 +1,210 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +var _typeof = require("@babel/runtime/helpers/typeof"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = exports.OutlineItemInternal = void 0; + +var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends")); + +var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties")); + +var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray")); + +var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck")); + +var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass")); + +var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized")); + +var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits")); + +var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn")); + +var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf")); + +var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty")); + +var _react = _interopRequireWildcard(require("react")); + +var _propTypes = _interopRequireDefault(require("prop-types")); + +var _DocumentContext = _interopRequireDefault(require("./DocumentContext")); + +var _OutlineContext = _interopRequireDefault(require("./OutlineContext")); + +var _Ref = _interopRequireDefault(require("./Ref")); + +var _utils = require("./shared/utils"); + +var _propTypes2 = require("./shared/propTypes"); + +var _excluded = ["item"]; + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +var OutlineItemInternal = /*#__PURE__*/function (_PureComponent) { + (0, _inherits2["default"])(OutlineItemInternal, _PureComponent); + + var _super = _createSuper(OutlineItemInternal); + + function OutlineItemInternal() { + var _this; + + (0, _classCallCheck2["default"])(this, OutlineItemInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "getDestination", function () { + return new Promise(function (resolve, reject) { + var _this$props = _this.props, + item = _this$props.item, + pdf = _this$props.pdf; + + if (!(0, _utils.isDefined)(_this.destination)) { + if (typeof item.dest === 'string') { + pdf.getDestination(item.dest).then(resolve)["catch"](reject); + } else { + resolve(item.dest); + } + } + + return _this.destination; + }).then(function (destination) { + _this.destination = destination; + return destination; + }); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "getPageIndex", function () { + return new Promise(function (resolve, reject) { + var pdf = _this.props.pdf; + + if ((0, _utils.isDefined)(_this.pageIndex)) { + resolve(_this.pageIndex); + } + + _this.getDestination().then(function (destination) { + if (!destination) { + return; + } + + var _destination = (0, _slicedToArray2["default"])(destination, 1), + ref = _destination[0]; + + pdf.getPageIndex(new _Ref["default"](ref)).then(resolve)["catch"](reject); + }); + }).then(function (pageIndex) { + _this.pageIndex = pageIndex; + return _this.pageIndex; + }); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "getPageNumber", function () { + return new Promise(function (resolve, reject) { + if ((0, _utils.isDefined)(_this.pageNumber)) { + resolve(_this.pageNumber); + } + + _this.getPageIndex().then(function (pageIndex) { + resolve(pageIndex + 1); + })["catch"](reject); + }).then(function (pageNumber) { + _this.pageNumber = pageNumber; + return pageNumber; + }); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onClick", function (event) { + var onClick = _this.props.onClick; + event.preventDefault(); + + if (!onClick) { + return false; + } + + return Promise.all([_this.getDestination(), _this.getPageIndex(), _this.getPageNumber()]).then(function (_ref) { + var _ref2 = (0, _slicedToArray2["default"])(_ref, 3), + dest = _ref2[0], + pageIndex = _ref2[1], + pageNumber = _ref2[2]; + + onClick({ + dest: dest, + pageIndex: pageIndex, + pageNumber: pageNumber + }); + }); + }); + return _this; + } + + (0, _createClass2["default"])(OutlineItemInternal, [{ + key: "renderSubitems", + value: function renderSubitems() { + var _this$props2 = this.props, + item = _this$props2.item, + otherProps = (0, _objectWithoutProperties2["default"])(_this$props2, _excluded); + + if (!item.items || !item.items.length) { + return null; + } + + var subitems = item.items; + return /*#__PURE__*/_react["default"].createElement("ul", null, subitems.map(function (subitem, subitemIndex) { + return /*#__PURE__*/_react["default"].createElement(OutlineItemInternal, (0, _extends2["default"])({ + key: typeof subitem.destination === 'string' ? subitem.destination : subitemIndex, + item: subitem + }, otherProps)); + })); + } + }, { + key: "render", + value: function render() { + var item = this.props.item; + return /*#__PURE__*/_react["default"].createElement("li", null, /*#__PURE__*/_react["default"].createElement("a", { + href: "#", + onClick: this.onClick + }, item.title), this.renderSubitems()); + } + }]); + return OutlineItemInternal; +}(_react.PureComponent); + +exports.OutlineItemInternal = OutlineItemInternal; + +var isDestination = _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].arrayOf(_propTypes["default"].any)]); + +OutlineItemInternal.propTypes = { + item: _propTypes["default"].shape({ + dest: isDestination, + items: _propTypes["default"].arrayOf(_propTypes["default"].shape({ + dest: isDestination, + title: _propTypes["default"].string + })), + title: _propTypes["default"].string + }).isRequired, + onClick: _propTypes["default"].func, + pdf: _propTypes2.isPdf.isRequired +}; + +var OutlineItem = function OutlineItem(props) { + return /*#__PURE__*/_react["default"].createElement(_DocumentContext["default"].Consumer, null, function (documentContext) { + return /*#__PURE__*/_react["default"].createElement(_OutlineContext["default"].Consumer, null, function (outlineContext) { + return /*#__PURE__*/_react["default"].createElement(OutlineItemInternal, (0, _extends2["default"])({}, documentContext, outlineContext, props)); + }); + }); +}; + +var _default = OutlineItem; +exports["default"] = _default; \ No newline at end of file diff --git a/dist/umd/Page.js b/dist/umd/Page.js new file mode 100644 index 000000000..a908b34df --- /dev/null +++ b/dist/umd/Page.js @@ -0,0 +1,504 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +var _typeof = require("@babel/runtime/helpers/typeof"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = exports.PageInternal = void 0; + +var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends")); + +var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck")); + +var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass")); + +var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized")); + +var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits")); + +var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn")); + +var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf")); + +var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty")); + +var _react = _interopRequireWildcard(require("react")); + +var _propTypes = _interopRequireDefault(require("prop-types")); + +var _makeCancellablePromise = _interopRequireDefault(require("make-cancellable-promise")); + +var _makeEventProps = _interopRequireDefault(require("make-event-props")); + +var _mergeClassNames = _interopRequireDefault(require("merge-class-names")); + +var _mergeRefs = _interopRequireDefault(require("merge-refs")); + +var _tinyInvariant = _interopRequireDefault(require("tiny-invariant")); + +var _tinyWarning = _interopRequireDefault(require("tiny-warning")); + +var _DocumentContext = _interopRequireDefault(require("./DocumentContext")); + +var _PageContext = _interopRequireDefault(require("./PageContext")); + +var _Message = _interopRequireDefault(require("./Message")); + +var _PageCanvas = _interopRequireDefault(require("./Page/PageCanvas")); + +var _PageSVG = _interopRequireDefault(require("./Page/PageSVG")); + +var _TextLayer = _interopRequireDefault(require("./Page/TextLayer")); + +var _AnnotationLayer = _interopRequireDefault(require("./Page/AnnotationLayer")); + +var _utils = require("./shared/utils"); + +var _propTypes2 = require("./shared/propTypes"); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +var defaultScale = 1; + +var PageInternal = /*#__PURE__*/function (_PureComponent) { + (0, _inherits2["default"])(PageInternal, _PureComponent); + + var _super = _createSuper(PageInternal); + + function PageInternal() { + var _this; + + (0, _classCallCheck2["default"])(this, PageInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "state", { + page: null + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "pageElement", /*#__PURE__*/(0, _react.createRef)()); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onLoadSuccess", function () { + var _this$props = _this.props, + onLoadSuccess = _this$props.onLoadSuccess, + registerPage = _this$props.registerPage; + var page = _this.state.page; + + if (onLoadSuccess) { + if (!page || !_this.scale) { + return; + } + + onLoadSuccess((0, _utils.makePageCallback)(page, _this.scale)); + } + + if (registerPage) registerPage(_this.pageIndex, _this.pageElement.current); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onLoadError", function (error) { + _this.setState({ + page: false + }); + + (0, _tinyWarning["default"])(error); + var onLoadError = _this.props.onLoadError; + if (onLoadError) onLoadError(error); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "loadPage", function () { + var pdf = _this.props.pdf; + + var pageNumber = _this.getPageNumber(); + + if (!pageNumber) { + return; + } + + _this.setState(function (prevState) { + if (!prevState.page) { + return null; + } + + return { + page: null + }; + }); + + var cancellable = (0, _makeCancellablePromise["default"])(pdf.getPage(pageNumber)); + _this.runningTask = cancellable; + cancellable.promise.then(function (page) { + _this.setState({ + page: page + }, _this.onLoadSuccess); + })["catch"](function (error) { + _this.onLoadError(error); + }); + }); + return _this; + } + + (0, _createClass2["default"])(PageInternal, [{ + key: "componentDidMount", + value: function componentDidMount() { + var pdf = this.props.pdf; + (0, _tinyInvariant["default"])(pdf, 'Attempted to load a page, but no document was specified.'); + this.loadPage(); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var pdf = this.props.pdf; + + if (prevProps.pdf && pdf !== prevProps.pdf || this.getPageNumber() !== this.getPageNumber(prevProps)) { + var unregisterPage = this.props.unregisterPage; + if (unregisterPage) unregisterPage(this.getPageIndex(prevProps)); + this.loadPage(); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + var unregisterPage = this.props.unregisterPage; + if (unregisterPage) unregisterPage(this.pageIndex); + (0, _utils.cancelRunningTask)(this.runningTask); + } + }, { + key: "childContext", + get: function get() { + var page = this.state.page; + + if (!page) { + return {}; + } + + var _this$props2 = this.props, + canvasBackground = _this$props2.canvasBackground, + customTextRenderer = _this$props2.customTextRenderer, + onGetAnnotationsError = _this$props2.onGetAnnotationsError, + onGetAnnotationsSuccess = _this$props2.onGetAnnotationsSuccess, + onGetTextError = _this$props2.onGetTextError, + onGetTextSuccess = _this$props2.onGetTextSuccess, + onRenderAnnotationLayerError = _this$props2.onRenderAnnotationLayerError, + onRenderAnnotationLayerSuccess = _this$props2.onRenderAnnotationLayerSuccess, + onRenderError = _this$props2.onRenderError, + onRenderSuccess = _this$props2.onRenderSuccess, + renderForms = _this$props2.renderForms, + renderInteractiveForms = _this$props2.renderInteractiveForms; + return { + canvasBackground: canvasBackground, + customTextRenderer: customTextRenderer, + onGetAnnotationsError: onGetAnnotationsError, + onGetAnnotationsSuccess: onGetAnnotationsSuccess, + onGetTextError: onGetTextError, + onGetTextSuccess: onGetTextSuccess, + onRenderAnnotationLayerError: onRenderAnnotationLayerError, + onRenderAnnotationLayerSuccess: onRenderAnnotationLayerSuccess, + onRenderError: onRenderError, + onRenderSuccess: onRenderSuccess, + page: page, + renderForms: renderForms !== null && renderForms !== void 0 ? renderForms : renderInteractiveForms, + // For backward compatibility + rotate: this.rotate, + scale: this.scale + }; + } + /** + * Called when a page is loaded successfully + */ + + }, { + key: "getPageIndex", + value: function getPageIndex() { + var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props; + + if ((0, _utils.isProvided)(props.pageNumber)) { + return props.pageNumber - 1; + } + + if ((0, _utils.isProvided)(props.pageIndex)) { + return props.pageIndex; + } + + return null; + } + }, { + key: "getPageNumber", + value: function getPageNumber() { + var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props; + + if ((0, _utils.isProvided)(props.pageNumber)) { + return props.pageNumber; + } + + if ((0, _utils.isProvided)(props.pageIndex)) { + return props.pageIndex + 1; + } + + return null; + } + }, { + key: "pageIndex", + get: function get() { + return this.getPageIndex(); + } + }, { + key: "pageNumber", + get: function get() { + return this.getPageNumber(); + } + }, { + key: "rotate", + get: function get() { + var rotate = this.props.rotate; + + if ((0, _utils.isProvided)(rotate)) { + return rotate; + } + + var page = this.state.page; + + if (!page) { + return null; + } + + return page.rotate; + } + }, { + key: "scale", + get: function get() { + var page = this.state.page; + + if (!page) { + return null; + } + + var _this$props3 = this.props, + scale = _this$props3.scale, + width = _this$props3.width, + height = _this$props3.height; + var rotate = this.rotate; // Be default, we'll render page at 100% * scale width. + + var pageScale = 1; // Passing scale explicitly null would cause the page not to render + + var scaleWithDefault = scale === null ? defaultScale : scale; // If width/height is defined, calculate the scale of the page so it could be of desired width. + + if (width || height) { + var viewport = page.getViewport({ + scale: 1, + rotation: rotate + }); + pageScale = width ? width / viewport.width : height / viewport.height; + } + + return scaleWithDefault * pageScale; + } + }, { + key: "eventProps", + get: function get() { + var _this2 = this; + + return (0, _makeEventProps["default"])(this.props, function () { + var page = _this2.state.page; + + if (!page) { + return page; + } + + return (0, _utils.makePageCallback)(page, _this2.scale); + }); + } + }, { + key: "pageKey", + get: function get() { + var page = this.state.page; + return "".concat(page.pageIndex, "@").concat(this.scale, "/").concat(this.rotate); + } + }, { + key: "pageKeyNoScale", + get: function get() { + var page = this.state.page; + return "".concat(page.pageIndex, "/").concat(this.rotate); + } + }, { + key: "renderMainLayer", + value: function renderMainLayer() { + var _this$props4 = this.props, + canvasRef = _this$props4.canvasRef, + renderMode = _this$props4.renderMode; + + switch (renderMode) { + case 'none': + return null; + + case 'svg': + return /*#__PURE__*/_react["default"].createElement(_PageSVG["default"], { + key: "".concat(this.pageKeyNoScale, "_svg") + }); + + case 'canvas': + default: + return /*#__PURE__*/_react["default"].createElement(_PageCanvas["default"], { + key: "".concat(this.pageKey, "_canvas"), + canvasRef: canvasRef + }); + } + } + }, { + key: "renderTextLayer", + value: function renderTextLayer() { + var renderTextLayer = this.props.renderTextLayer; + + if (!renderTextLayer) { + return null; + } + + return /*#__PURE__*/_react["default"].createElement(_TextLayer["default"], { + key: "".concat(this.pageKey, "_text") + }); + } + }, { + key: "renderAnnotationLayer", + value: function renderAnnotationLayer() { + var renderAnnotationLayer = this.props.renderAnnotationLayer; + + if (!renderAnnotationLayer) { + return null; + } + /** + * As of now, PDF.js 2.0.943 returns warnings on unimplemented annotations in SVG mode. + * Therefore, as a fallback, we render "traditional" AnnotationLayer component. + */ + + + return /*#__PURE__*/_react["default"].createElement(_AnnotationLayer["default"], { + key: "".concat(this.pageKey, "_annotations") + }); + } + }, { + key: "renderChildren", + value: function renderChildren() { + var children = this.props.children; + return /*#__PURE__*/_react["default"].createElement(_PageContext["default"].Provider, { + value: this.childContext + }, this.renderMainLayer(), this.renderTextLayer(), this.renderAnnotationLayer(), children); + } + }, { + key: "renderContent", + value: function renderContent() { + var pageNumber = this.pageNumber; + var pdf = this.props.pdf; + var page = this.state.page; + + if (!pageNumber) { + var noData = this.props.noData; + return /*#__PURE__*/_react["default"].createElement(_Message["default"], { + type: "no-data" + }, typeof noData === 'function' ? noData() : noData); + } + + if (pdf === null || page === null) { + var loading = this.props.loading; + return /*#__PURE__*/_react["default"].createElement(_Message["default"], { + type: "loading" + }, typeof loading === 'function' ? loading() : loading); + } + + if (pdf === false || page === false) { + var error = this.props.error; + return /*#__PURE__*/_react["default"].createElement(_Message["default"], { + type: "error" + }, typeof error === 'function' ? error() : error); + } + + return this.renderChildren(); + } + }, { + key: "render", + value: function render() { + var pageNumber = this.pageNumber; + var _this$props5 = this.props, + className = _this$props5.className, + inputRef = _this$props5.inputRef; + return /*#__PURE__*/_react["default"].createElement("div", (0, _extends2["default"])({ + className: (0, _mergeClassNames["default"])('react-pdf__Page', className), + "data-page-number": pageNumber, + ref: (0, _mergeRefs["default"])(inputRef, this.pageElement), + style: { + position: 'relative' + } + }, this.eventProps), this.renderContent()); + } + }]); + return PageInternal; +}(_react.PureComponent); + +exports.PageInternal = PageInternal; +PageInternal.defaultProps = { + error: 'Failed to load the page.', + loading: 'Loading page…', + noData: 'No page specified.', + renderAnnotationLayer: true, + renderForms: false, + renderMode: 'canvas', + renderTextLayer: true, + scale: defaultScale +}; + +var isFunctionOrNode = _propTypes["default"].oneOfType([_propTypes["default"].func, _propTypes["default"].node]); + +PageInternal.propTypes = _objectSpread(_objectSpread({}, _propTypes2.eventProps), {}, { + canvasBackground: _propTypes["default"].string, + children: _propTypes["default"].node, + className: _propTypes2.isClassName, + customTextRenderer: _propTypes["default"].func, + error: isFunctionOrNode, + height: _propTypes["default"].number, + imageResourcesPath: _propTypes["default"].string, + inputRef: _propTypes2.isRef, + loading: isFunctionOrNode, + noData: isFunctionOrNode, + onGetTextError: _propTypes["default"].func, + onGetTextSuccess: _propTypes["default"].func, + onLoadError: _propTypes["default"].func, + onLoadSuccess: _propTypes["default"].func, + onRenderError: _propTypes["default"].func, + onRenderSuccess: _propTypes["default"].func, + pageIndex: _propTypes2.isPageIndex, + pageNumber: _propTypes2.isPageNumber, + pdf: _propTypes2.isPdf, + registerPage: _propTypes["default"].func, + renderAnnotationLayer: _propTypes["default"].bool, + renderForms: _propTypes["default"].bool, + renderInteractiveForms: _propTypes["default"].bool, + // For backward compatibility + renderMode: _propTypes2.isRenderMode, + renderTextLayer: _propTypes["default"].bool, + rotate: _propTypes2.isRotate, + scale: _propTypes["default"].number, + unregisterPage: _propTypes["default"].func, + width: _propTypes["default"].number +}); + +function Page(props, ref) { + return /*#__PURE__*/_react["default"].createElement(_DocumentContext["default"].Consumer, null, function (context) { + return /*#__PURE__*/_react["default"].createElement(PageInternal, (0, _extends2["default"])({ + ref: ref + }, context, props)); + }); +} + +var _default = /*#__PURE__*/_react["default"].forwardRef(Page); + +exports["default"] = _default; \ No newline at end of file diff --git a/dist/umd/Page/AnnotationLayer.css b/dist/umd/Page/AnnotationLayer.css new file mode 100644 index 000000000..2713074cc --- /dev/null +++ b/dist/umd/Page/AnnotationLayer.css @@ -0,0 +1,232 @@ +/* Copyright 2014 Mozilla Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +:root { + --annotation-unfocused-field-background: url("data:image/svg+xml;charset=UTF-8,"); +} + +.annotationLayer section { + position: absolute; + text-align: initial; +} + +.annotationLayer .linkAnnotation > a, +.annotationLayer .buttonWidgetAnnotation.pushButton > a { + position: absolute; + font-size: 1em; + top: 0; + left: 0; + width: 100%; + height: 100%; +} + +.annotationLayer .buttonWidgetAnnotation.pushButton > canvas { + position: relative; + top: 0; + left: 0; + z-index: -1; +} + +.annotationLayer .linkAnnotation > a:hover, +.annotationLayer .buttonWidgetAnnotation.pushButton > a:hover { + opacity: 0.2; + background: rgba(255, 255, 0, 1); + box-shadow: 0 2px 10px rgba(255, 255, 0, 1); +} + +.annotationLayer .textAnnotation img { + position: absolute; + cursor: pointer; +} + +.annotationLayer .textWidgetAnnotation input, +.annotationLayer .textWidgetAnnotation textarea, +.annotationLayer .choiceWidgetAnnotation select, +.annotationLayer .buttonWidgetAnnotation.checkBox input, +.annotationLayer .buttonWidgetAnnotation.radioButton input { + background-image: var(--annotation-unfocused-field-background); + border: 1px solid transparent; + box-sizing: border-box; + font-size: 9px; + height: 100%; + margin: 0; + padding: 0 3px; + vertical-align: top; + width: 100%; +} + +.annotationLayer .choiceWidgetAnnotation select option { + padding: 0; +} + +.annotationLayer .buttonWidgetAnnotation.radioButton input { + border-radius: 50%; +} + +.annotationLayer .textWidgetAnnotation textarea { + font: message-box; + font-size: 9px; + resize: none; +} + +.annotationLayer .textWidgetAnnotation input[disabled], +.annotationLayer .textWidgetAnnotation textarea[disabled], +.annotationLayer .choiceWidgetAnnotation select[disabled], +.annotationLayer .buttonWidgetAnnotation.checkBox input[disabled], +.annotationLayer .buttonWidgetAnnotation.radioButton input[disabled] { + background: none; + border: 1px solid transparent; + cursor: not-allowed; +} + +.annotationLayer .textWidgetAnnotation input:hover, +.annotationLayer .textWidgetAnnotation textarea:hover, +.annotationLayer .choiceWidgetAnnotation select:hover, +.annotationLayer .buttonWidgetAnnotation.checkBox input:hover, +.annotationLayer .buttonWidgetAnnotation.radioButton input:hover { + border: 1px solid rgba(0, 0, 0, 1); +} + +.annotationLayer .textWidgetAnnotation input:focus, +.annotationLayer .textWidgetAnnotation textarea:focus, +.annotationLayer .choiceWidgetAnnotation select:focus { + background: none; + border: 1px solid transparent; +} + +.annotationLayer .textWidgetAnnotation input :focus, +.annotationLayer .textWidgetAnnotation textarea :focus, +.annotationLayer .choiceWidgetAnnotation select :focus, +.annotationLayer .buttonWidgetAnnotation.checkBox :focus, +.annotationLayer .buttonWidgetAnnotation.radioButton :focus { + background-image: none; + background-color: transparent; + outline: auto; +} + +.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:before, +.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:after, +.annotationLayer .buttonWidgetAnnotation.radioButton input:checked:before { + background-color: rgba(0, 0, 0, 1); + content: ''; + display: block; + position: absolute; +} + +.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:before, +.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:after { + height: 80%; + left: 45%; + width: 1px; +} + +.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:before { + transform: rotate(45deg); +} + +.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:after { + transform: rotate(-45deg); +} + +.annotationLayer .buttonWidgetAnnotation.radioButton input:checked:before { + border-radius: 50%; + height: 50%; + left: 30%; + top: 20%; + width: 50%; +} + +.annotationLayer .textWidgetAnnotation input.comb { + font-family: monospace; + padding-left: 2px; + padding-right: 0; +} + +.annotationLayer .textWidgetAnnotation input.comb:focus { + /* + * Letter spacing is placed on the right side of each character. Hence, the + * letter spacing of the last character may be placed outside the visible + * area, causing horizontal scrolling. We avoid this by extending the width + * when the element has focus and revert this when it loses focus. + */ + width: 103%; +} + +.annotationLayer .buttonWidgetAnnotation.checkBox input, +.annotationLayer .buttonWidgetAnnotation.radioButton input { + appearance: none; + padding: 0; +} + +.annotationLayer .popupWrapper { + position: absolute; + width: 20em; +} + +.annotationLayer .popup { + position: absolute; + z-index: 200; + max-width: 20em; + background-color: rgba(255, 255, 153, 1); + box-shadow: 0 2px 5px rgba(136, 136, 136, 1); + border-radius: 2px; + padding: 6px; + margin-left: 5px; + cursor: pointer; + font: message-box; + font-size: 9px; + white-space: normal; + word-wrap: break-word; +} + +.annotationLayer .popup > * { + font-size: 9px; +} + +.annotationLayer .popup h1 { + display: inline-block; +} + +.annotationLayer .popupDate { + display: inline-block; + margin-left: 5px; +} + +.annotationLayer .popupContent { + border-top: 1px solid rgba(51, 51, 51, 1); + margin-top: 2px; + padding-top: 2px; +} + +.annotationLayer .richText > * { + white-space: pre-wrap; +} + +.annotationLayer .highlightAnnotation, +.annotationLayer .underlineAnnotation, +.annotationLayer .squigglyAnnotation, +.annotationLayer .strikeoutAnnotation, +.annotationLayer .freeTextAnnotation, +.annotationLayer .lineAnnotation svg line, +.annotationLayer .squareAnnotation svg rect, +.annotationLayer .circleAnnotation svg ellipse, +.annotationLayer .polylineAnnotation svg polyline, +.annotationLayer .polygonAnnotation svg polygon, +.annotationLayer .caretAnnotation, +.annotationLayer .inkAnnotation svg polyline, +.annotationLayer .stampAnnotation, +.annotationLayer .fileAttachmentAnnotation { + cursor: pointer; +} diff --git a/dist/umd/Page/AnnotationLayer.js b/dist/umd/Page/AnnotationLayer.js new file mode 100644 index 000000000..9eb3c087b --- /dev/null +++ b/dist/umd/Page/AnnotationLayer.js @@ -0,0 +1,218 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +var _typeof = require("@babel/runtime/helpers/typeof"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = exports.AnnotationLayerInternal = void 0; + +var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends")); + +var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck")); + +var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass")); + +var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized")); + +var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits")); + +var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn")); + +var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf")); + +var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty")); + +var _react = _interopRequireWildcard(require("react")); + +var _propTypes = _interopRequireDefault(require("prop-types")); + +var _makeCancellablePromise = _interopRequireDefault(require("make-cancellable-promise")); + +var _tinyInvariant = _interopRequireDefault(require("tiny-invariant")); + +var _tinyWarning = _interopRequireDefault(require("tiny-warning")); + +var pdfjs = _interopRequireWildcard(require("pdfjs-dist/legacy/build/pdf")); + +var _DocumentContext = _interopRequireDefault(require("../DocumentContext")); + +var _PageContext = _interopRequireDefault(require("../PageContext")); + +var _utils = require("../shared/utils"); + +var _propTypes2 = require("../shared/propTypes"); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +var AnnotationLayerInternal = /*#__PURE__*/function (_PureComponent) { + (0, _inherits2["default"])(AnnotationLayerInternal, _PureComponent); + + var _super = _createSuper(AnnotationLayerInternal); + + function AnnotationLayerInternal() { + var _this; + + (0, _classCallCheck2["default"])(this, AnnotationLayerInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "state", { + annotations: null + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "layerElement", /*#__PURE__*/(0, _react.createRef)()); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "loadAnnotations", function () { + var page = _this.props.page; + var cancellable = (0, _makeCancellablePromise["default"])(page.getAnnotations()); + _this.runningTask = cancellable; + cancellable.promise.then(function (annotations) { + _this.setState({ + annotations: annotations + }, _this.onLoadSuccess); + })["catch"](function (error) { + _this.onLoadError(error); + }); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onLoadSuccess", function () { + var onGetAnnotationsSuccess = _this.props.onGetAnnotationsSuccess; + var annotations = _this.state.annotations; + if (onGetAnnotationsSuccess) onGetAnnotationsSuccess(annotations); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onLoadError", function (error) { + _this.setState({ + annotations: false + }); + + (0, _tinyWarning["default"])(error); + var onGetAnnotationsError = _this.props.onGetAnnotationsError; + if (onGetAnnotationsError) onGetAnnotationsError(error); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onRenderSuccess", function () { + var onRenderAnnotationLayerSuccess = _this.props.onRenderAnnotationLayerSuccess; + if (onRenderAnnotationLayerSuccess) onRenderAnnotationLayerSuccess(); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onRenderError", function (error) { + (0, _tinyWarning["default"])(error); + var onRenderAnnotationLayerError = _this.props.onRenderAnnotationLayerError; + if (onRenderAnnotationLayerError) onRenderAnnotationLayerError(error); + }); + return _this; + } + + (0, _createClass2["default"])(AnnotationLayerInternal, [{ + key: "componentDidMount", + value: function componentDidMount() { + var page = this.props.page; + (0, _tinyInvariant["default"])(page, 'Attempted to load page annotations, but no page was specified.'); + this.loadAnnotations(); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var _this$props = this.props, + page = _this$props.page, + renderForms = _this$props.renderForms; + + if (prevProps.page && page !== prevProps.page || renderForms !== prevProps.renderForms) { + this.loadAnnotations(); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + (0, _utils.cancelRunningTask)(this.runningTask); + } + }, { + key: "viewport", + get: function get() { + var _this$props2 = this.props, + page = _this$props2.page, + rotate = _this$props2.rotate, + scale = _this$props2.scale; + return page.getViewport({ + scale: scale, + rotation: rotate + }); + } + }, { + key: "renderAnnotationLayer", + value: function renderAnnotationLayer() { + var annotations = this.state.annotations; + + if (!annotations) { + return; + } + + var _this$props3 = this.props, + imageResourcesPath = _this$props3.imageResourcesPath, + linkService = _this$props3.linkService, + page = _this$props3.page, + renderForms = _this$props3.renderForms; + var viewport = this.viewport.clone({ + dontFlip: true + }); + var parameters = { + annotations: annotations, + div: this.layerElement.current, + imageResourcesPath: imageResourcesPath, + linkService: linkService, + page: page, + renderForms: renderForms, + viewport: viewport + }; + this.layerElement.current.innerHTML = ''; + + try { + pdfjs.AnnotationLayer.render(parameters); + this.onRenderSuccess(); + } catch (error) { + this.onRenderError(error); + } + } + }, { + key: "render", + value: function render() { + return /*#__PURE__*/_react["default"].createElement("div", { + className: "react-pdf__Page__annotations annotationLayer", + ref: this.layerElement + }, this.renderAnnotationLayer()); + } + }]); + return AnnotationLayerInternal; +}(_react.PureComponent); + +exports.AnnotationLayerInternal = AnnotationLayerInternal; +AnnotationLayerInternal.propTypes = { + imageResourcesPath: _propTypes["default"].string, + linkService: _propTypes2.isLinkService.isRequired, + onGetAnnotationsError: _propTypes["default"].func, + onGetAnnotationsSuccess: _propTypes["default"].func, + onRenderAnnotationLayerError: _propTypes["default"].func, + onRenderAnnotationLayerSuccess: _propTypes["default"].func, + page: _propTypes2.isPage, + renderForms: _propTypes["default"].bool, + rotate: _propTypes2.isRotate, + scale: _propTypes["default"].number +}; + +var AnnotationLayer = function AnnotationLayer(props) { + return /*#__PURE__*/_react["default"].createElement(_DocumentContext["default"].Consumer, null, function (documentContext) { + return /*#__PURE__*/_react["default"].createElement(_PageContext["default"].Consumer, null, function (pageContext) { + return /*#__PURE__*/_react["default"].createElement(AnnotationLayerInternal, (0, _extends2["default"])({}, documentContext, pageContext, props)); + }); + }); +}; + +var _default = AnnotationLayer; +exports["default"] = _default; \ No newline at end of file diff --git a/dist/umd/Page/PageCanvas.js b/dist/umd/Page/PageCanvas.js new file mode 100644 index 000000000..3915fe04c --- /dev/null +++ b/dist/umd/Page/PageCanvas.js @@ -0,0 +1,235 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +var _typeof = require("@babel/runtime/helpers/typeof"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.PageCanvasInternal = void 0; +exports["default"] = PageCanvas; + +var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends")); + +var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck")); + +var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass")); + +var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized")); + +var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits")); + +var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn")); + +var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf")); + +var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty")); + +var _react = _interopRequireWildcard(require("react")); + +var _propTypes = _interopRequireDefault(require("prop-types")); + +var _mergeRefs = _interopRequireDefault(require("merge-refs")); + +var _tinyWarning = _interopRequireDefault(require("tiny-warning")); + +var pdfjs = _interopRequireWildcard(require("pdfjs-dist/legacy/build/pdf")); + +var _PageContext = _interopRequireDefault(require("../PageContext")); + +var _utils = require("../shared/utils"); + +var _propTypes2 = require("../shared/propTypes"); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +var ANNOTATION_MODE = pdfjs.AnnotationMode; + +var PageCanvasInternal = /*#__PURE__*/function (_PureComponent) { + (0, _inherits2["default"])(PageCanvasInternal, _PureComponent); + + var _super = _createSuper(PageCanvasInternal); + + function PageCanvasInternal() { + var _this; + + (0, _classCallCheck2["default"])(this, PageCanvasInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "canvasElement", /*#__PURE__*/(0, _react.createRef)()); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onRenderSuccess", function () { + _this.renderer = null; + var _this$props = _this.props, + onRenderSuccess = _this$props.onRenderSuccess, + page = _this$props.page, + scale = _this$props.scale; + if (onRenderSuccess) onRenderSuccess((0, _utils.makePageCallback)(page, scale)); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onRenderError", function (error) { + if ((0, _utils.isCancelException)(error)) { + return; + } + + (0, _tinyWarning["default"])(error); + var onRenderError = _this.props.onRenderError; + if (onRenderError) onRenderError(error); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "drawPageOnCanvas", function () { + var canvas = _this.canvasElement.current; + + if (!canvas) { + return null; + } + + var _assertThisInitialize = (0, _assertThisInitialized2["default"])(_this), + renderViewport = _assertThisInitialize.renderViewport, + viewport = _assertThisInitialize.viewport; + + var _this$props2 = _this.props, + canvasBackground = _this$props2.canvasBackground, + page = _this$props2.page, + renderForms = _this$props2.renderForms; + canvas.width = renderViewport.width; + canvas.height = renderViewport.height; + canvas.style.width = "".concat(Math.floor(viewport.width), "px"); + canvas.style.height = "".concat(Math.floor(viewport.height), "px"); + var renderContext = { + annotationMode: renderForms ? ANNOTATION_MODE.ENABLE_FORMS : ANNOTATION_MODE.ENABLE, + + get canvasContext() { + return canvas.getContext('2d'); + }, + + viewport: renderViewport + }; + + if (canvasBackground) { + renderContext.background = canvasBackground; + } // If another render is in progress, let's cancel it + + + _this.cancelRenderingTask(); + + _this.renderer = page.render(renderContext); + return _this.renderer.promise.then(_this.onRenderSuccess)["catch"](_this.onRenderError); + }); + return _this; + } + + (0, _createClass2["default"])(PageCanvasInternal, [{ + key: "componentDidMount", + value: function componentDidMount() { + this.drawPageOnCanvas(); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var _this$props3 = this.props, + canvasBackground = _this$props3.canvasBackground, + page = _this$props3.page, + renderForms = _this$props3.renderForms; + + if (canvasBackground !== prevProps.canvasBackground || renderForms !== prevProps.renderForms) { + // Ensures the canvas will be re-rendered from scratch. Otherwise all form data will stay. + page.cleanup(); + this.drawPageOnCanvas(); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + this.cancelRenderingTask(); + var canvas = this.canvasElement.current; + /** + * 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; + } + } + }, { + key: "cancelRenderingTask", + value: function cancelRenderingTask() { + if (this.renderer) { + this.renderer.cancel(); + this.renderer = null; + } + } + /** + * Called when a page is rendered successfully. + */ + + }, { + key: "renderViewport", + get: function get() { + var _this$props4 = this.props, + page = _this$props4.page, + rotate = _this$props4.rotate, + scale = _this$props4.scale; + var pixelRatio = (0, _utils.getPixelRatio)(); + return page.getViewport({ + scale: scale * pixelRatio, + rotation: rotate + }); + } + }, { + key: "viewport", + get: function get() { + var _this$props5 = this.props, + page = _this$props5.page, + rotate = _this$props5.rotate, + scale = _this$props5.scale; + return page.getViewport({ + scale: scale, + rotation: rotate + }); + } + }, { + key: "render", + value: function render() { + var canvasRef = this.props.canvasRef; + return /*#__PURE__*/_react["default"].createElement("canvas", { + className: "react-pdf__Page__canvas", + dir: "ltr", + ref: (0, _mergeRefs["default"])(canvasRef, this.canvasElement), + style: { + display: 'block', + userSelect: 'none' + } + }); + } + }]); + return PageCanvasInternal; +}(_react.PureComponent); + +exports.PageCanvasInternal = PageCanvasInternal; +PageCanvasInternal.propTypes = { + canvasBackground: _propTypes["default"].string, + canvasRef: _propTypes2.isRef, + onRenderError: _propTypes["default"].func, + onRenderSuccess: _propTypes["default"].func, + page: _propTypes2.isPage.isRequired, + renderForms: _propTypes["default"].bool, + rotate: _propTypes2.isRotate, + scale: _propTypes["default"].number.isRequired +}; + +function PageCanvas(props) { + return /*#__PURE__*/_react["default"].createElement(_PageContext["default"].Consumer, null, function (context) { + return /*#__PURE__*/_react["default"].createElement(PageCanvasInternal, (0, _extends2["default"])({}, context, props)); + }); +} \ No newline at end of file diff --git a/dist/umd/Page/PageSVG.js b/dist/umd/Page/PageSVG.js new file mode 100644 index 000000000..dad7f8f1f --- /dev/null +++ b/dist/umd/Page/PageSVG.js @@ -0,0 +1,181 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +var _typeof = require("@babel/runtime/helpers/typeof"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.PageSVGInternal = void 0; +exports["default"] = PageSVG; + +var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends")); + +var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck")); + +var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass")); + +var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized")); + +var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits")); + +var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn")); + +var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf")); + +var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty")); + +var _react = _interopRequireWildcard(require("react")); + +var _propTypes = _interopRequireDefault(require("prop-types")); + +var _tinyWarning = _interopRequireDefault(require("tiny-warning")); + +var pdfjs = _interopRequireWildcard(require("pdfjs-dist/legacy/build/pdf")); + +var _PageContext = _interopRequireDefault(require("../PageContext")); + +var _utils = require("../shared/utils"); + +var _propTypes2 = require("../shared/propTypes"); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +var PageSVGInternal = /*#__PURE__*/function (_PureComponent) { + (0, _inherits2["default"])(PageSVGInternal, _PureComponent); + + var _super = _createSuper(PageSVGInternal); + + function PageSVGInternal() { + var _this; + + (0, _classCallCheck2["default"])(this, PageSVGInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "state", { + svg: null + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onRenderSuccess", function () { + _this.renderer = null; + var _this$props = _this.props, + onRenderSuccess = _this$props.onRenderSuccess, + page = _this$props.page, + scale = _this$props.scale; + if (onRenderSuccess) onRenderSuccess((0, _utils.makePageCallback)(page, scale)); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onRenderError", function (error) { + if ((0, _utils.isCancelException)(error)) { + return; + } + + (0, _tinyWarning["default"])(error); + var onRenderError = _this.props.onRenderError; + if (onRenderError) onRenderError(error); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "renderSVG", function () { + var page = _this.props.page; + _this.renderer = page.getOperatorList(); + return _this.renderer.then(function (operatorList) { + var svgGfx = new pdfjs.SVGGraphics(page.commonObjs, page.objs); + _this.renderer = svgGfx.getSVG(operatorList, _this.viewport).then(function (svg) { + _this.setState({ + svg: svg + }, _this.onRenderSuccess); + })["catch"](_this.onRenderError); + })["catch"](_this.onRenderError); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "drawPageOnContainer", function (element) { + var svg = _this.state.svg; + + if (!element || !svg) { + return; + } // Append SVG element to the main container, if this hasn't been done already + + + if (!element.firstElementChild) { + element.appendChild(svg); + } + + var _this$viewport = _this.viewport, + width = _this$viewport.width, + height = _this$viewport.height; + svg.setAttribute('width', width); + svg.setAttribute('height', height); + }); + return _this; + } + + (0, _createClass2["default"])(PageSVGInternal, [{ + key: "componentDidMount", + value: function componentDidMount() { + this.renderSVG(); + } + /** + * Called when a page is rendered successfully. + */ + + }, { + key: "viewport", + get: function get() { + var _this$props2 = this.props, + page = _this$props2.page, + rotate = _this$props2.rotate, + scale = _this$props2.scale; + return page.getViewport({ + scale: scale, + rotation: rotate + }); + } + }, { + key: "render", + value: function render() { + var _this2 = this; + + var _this$viewport2 = this.viewport, + width = _this$viewport2.width, + height = _this$viewport2.height; + return /*#__PURE__*/_react["default"].createElement("div", { + className: "react-pdf__Page__svg" // Note: This cannot be shortened, as we need this function to be called with each render. + , + ref: function ref(_ref) { + return _this2.drawPageOnContainer(_ref); + }, + style: { + display: 'block', + backgroundColor: 'white', + overflow: 'hidden', + width: width, + height: height, + userSelect: 'none' + } + }); + } + }]); + return PageSVGInternal; +}(_react.PureComponent); + +exports.PageSVGInternal = PageSVGInternal; +PageSVGInternal.propTypes = { + onRenderError: _propTypes["default"].func, + onRenderSuccess: _propTypes["default"].func, + page: _propTypes2.isPage.isRequired, + rotate: _propTypes2.isRotate, + scale: _propTypes["default"].number.isRequired +}; + +function PageSVG(props) { + return /*#__PURE__*/_react["default"].createElement(_PageContext["default"].Consumer, null, function (context) { + return /*#__PURE__*/_react["default"].createElement(PageSVGInternal, (0, _extends2["default"])({}, context, props)); + }); +} \ No newline at end of file diff --git a/dist/umd/Page/TextLayer.js b/dist/umd/Page/TextLayer.js new file mode 100644 index 000000000..bad41ab82 --- /dev/null +++ b/dist/umd/Page/TextLayer.js @@ -0,0 +1,202 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +var _typeof = require("@babel/runtime/helpers/typeof"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.TextLayerInternal = void 0; +exports["default"] = TextLayer; + +var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends")); + +var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck")); + +var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass")); + +var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized")); + +var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits")); + +var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn")); + +var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf")); + +var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty")); + +var _react = _interopRequireWildcard(require("react")); + +var _propTypes = _interopRequireDefault(require("prop-types")); + +var _makeCancellablePromise = _interopRequireDefault(require("make-cancellable-promise")); + +var _tinyInvariant = _interopRequireDefault(require("tiny-invariant")); + +var _tinyWarning = _interopRequireDefault(require("tiny-warning")); + +var _PageContext = _interopRequireDefault(require("../PageContext")); + +var _TextLayerItem = _interopRequireDefault(require("./TextLayerItem")); + +var _utils = require("../shared/utils"); + +var _propTypes2 = require("../shared/propTypes"); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +var TextLayerInternal = /*#__PURE__*/function (_PureComponent) { + (0, _inherits2["default"])(TextLayerInternal, _PureComponent); + + var _super = _createSuper(TextLayerInternal); + + function TextLayerInternal() { + var _this; + + (0, _classCallCheck2["default"])(this, TextLayerInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "state", { + textItems: null + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "loadTextItems", function () { + var page = _this.props.page; + var cancellable = (0, _makeCancellablePromise["default"])(page.getTextContent()); + _this.runningTask = cancellable; + cancellable.promise.then(function (_ref) { + var textItems = _ref.items; + + _this.setState({ + textItems: textItems + }, _this.onLoadSuccess); + })["catch"](function (error) { + _this.onLoadError(error); + }); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onLoadSuccess", function () { + var onGetTextSuccess = _this.props.onGetTextSuccess; + var textItems = _this.state.textItems; + if (onGetTextSuccess) onGetTextSuccess(textItems); + }); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onLoadError", function (error) { + _this.setState({ + textItems: false + }); + + (0, _tinyWarning["default"])(error); + var onGetTextError = _this.props.onGetTextError; + if (onGetTextError) onGetTextError(error); + }); + return _this; + } + + (0, _createClass2["default"])(TextLayerInternal, [{ + key: "componentDidMount", + value: function componentDidMount() { + var page = this.props.page; + (0, _tinyInvariant["default"])(page, 'Attempted to load page text content, but no page was specified.'); + this.loadTextItems(); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var page = this.props.page; + + if (prevProps.page && page !== prevProps.page) { + this.loadTextItems(); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + (0, _utils.cancelRunningTask)(this.runningTask); + } + }, { + key: "unrotatedViewport", + get: function get() { + var _this$props = this.props, + page = _this$props.page, + scale = _this$props.scale; + return page.getViewport({ + scale: scale + }); + } + /** + * It might happen that the page is rotated by default. In such cases, we shouldn't rotate + * text content. + */ + + }, { + key: "rotate", + get: function get() { + var _this$props2 = this.props, + page = _this$props2.page, + rotate = _this$props2.rotate; + return rotate - page.rotate; + } + }, { + key: "renderTextItems", + value: function renderTextItems() { + var textItems = this.state.textItems; + + if (!textItems) { + return null; + } + + return textItems.map(function (textItem, itemIndex) { + return /*#__PURE__*/_react["default"].createElement(_TextLayerItem["default"] // eslint-disable-next-line react/no-array-index-key + , (0, _extends2["default"])({ + key: itemIndex, + itemIndex: itemIndex + }, textItem)); + }); + } + }, { + key: "render", + value: function render() { + var viewport = this.unrotatedViewport, + rotate = this.rotate; + return /*#__PURE__*/_react["default"].createElement("div", { + className: "react-pdf__Page__textContent", + style: { + position: 'absolute', + top: '50%', + left: '50%', + width: "".concat(viewport.width, "px"), + height: "".concat(viewport.height, "px"), + color: 'transparent', + transform: "translate(-50%, -50%) rotate(".concat(rotate, "deg)"), + WebkitTransform: "translate(-50%, -50%) rotate(".concat(rotate, "deg)"), + pointerEvents: 'none' + } + }, this.renderTextItems()); + } + }]); + return TextLayerInternal; +}(_react.PureComponent); + +exports.TextLayerInternal = TextLayerInternal; +TextLayerInternal.propTypes = { + onGetTextError: _propTypes["default"].func, + onGetTextSuccess: _propTypes["default"].func, + page: _propTypes2.isPage.isRequired, + rotate: _propTypes2.isRotate, + scale: _propTypes["default"].number +}; + +function TextLayer(props) { + return /*#__PURE__*/_react["default"].createElement(_PageContext["default"].Consumer, null, function (context) { + return /*#__PURE__*/_react["default"].createElement(TextLayerInternal, (0, _extends2["default"])({}, context, props)); + }); +} \ No newline at end of file diff --git a/dist/umd/Page/TextLayerItem.js b/dist/umd/Page/TextLayerItem.js new file mode 100644 index 000000000..86b521567 --- /dev/null +++ b/dist/umd/Page/TextLayerItem.js @@ -0,0 +1,269 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +var _typeof = require("@babel/runtime/helpers/typeof"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.TextLayerItemInternal = void 0; +exports["default"] = TextLayerItem; + +var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends")); + +var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray")); + +var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck")); + +var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass")); + +var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized")); + +var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits")); + +var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn")); + +var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf")); + +var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty")); + +var _react = _interopRequireWildcard(require("react")); + +var _propTypes = _interopRequireDefault(require("prop-types")); + +var _PageContext = _interopRequireDefault(require("../PageContext")); + +var _propTypes2 = require("../shared/propTypes"); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +var TextLayerItemInternal = /*#__PURE__*/function (_PureComponent) { + (0, _inherits2["default"])(TextLayerItemInternal, _PureComponent); + + var _super = _createSuper(TextLayerItemInternal); + + function TextLayerItemInternal() { + var _this; + + (0, _classCallCheck2["default"])(this, TextLayerItemInternal); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "itemElement", /*#__PURE__*/(0, _react.createRef)()); + (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "getElementWidth", function (element) { + var _assertThisInitialize = (0, _assertThisInitialized2["default"])(_this), + sideways = _assertThisInitialize.sideways; + + return element.getBoundingClientRect()[sideways ? 'height' : 'width']; + }); + return _this; + } + + (0, _createClass2["default"])(TextLayerItemInternal, [{ + key: "componentDidMount", + value: function componentDidMount() { + this.alignTextItem(); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate() { + this.alignTextItem(); + } + }, { + key: "unrotatedViewport", + get: function get() { + var _this$props = this.props, + page = _this$props.page, + scale = _this$props.scale; + return page.getViewport({ + scale: scale + }); + } + /** + * It might happen that the page is rotated by default. In such cases, we shouldn't rotate + * text content. + */ + + }, { + key: "rotate", + get: function get() { + var _this$props2 = this.props, + page = _this$props2.page, + rotate = _this$props2.rotate; + return rotate - page.rotate; + } + }, { + key: "sideways", + get: function get() { + var rotate = this.rotate; + return rotate % 180 !== 0; + } + }, { + key: "defaultSideways", + get: function get() { + var rotation = this.unrotatedViewport.rotation; + return rotation % 180 !== 0; + } + }, { + key: "fontSize", + get: function get() { + var transform = this.props.transform; + var defaultSideways = this.defaultSideways; + + var _transform = (0, _slicedToArray2["default"])(transform, 2), + fontHeightPx = _transform[0], + fontWidthPx = _transform[1]; + + return defaultSideways ? fontWidthPx : fontHeightPx; + } + }, { + key: "top", + get: function get() { + var transform = this.props.transform; + var viewport = this.unrotatedViewport, + defaultSideways = this.defaultSideways; + + var _transform2 = (0, _slicedToArray2["default"])(transform, 6), + + /* fontHeightPx */ + + /* fontWidthPx */ + offsetX = _transform2[2], + offsetY = _transform2[3], + x = _transform2[4], + y = _transform2[5]; + + var _viewport$viewBox = (0, _slicedToArray2["default"])(viewport.viewBox, 4), + + /* xMin */ + yMin + /* xMax */ + = _viewport$viewBox[1], + yMax = _viewport$viewBox[3]; + + return defaultSideways ? x + offsetX + yMin : yMax - (y + offsetY); + } + }, { + key: "left", + get: function get() { + var transform = this.props.transform; + var viewport = this.unrotatedViewport, + defaultSideways = this.defaultSideways; + + var _transform3 = (0, _slicedToArray2["default"])(transform, 6), + + /* fontHeightPx */ + + /* fontWidthPx */ + + /* offsetX */ + + /* offsetY */ + x = _transform3[4], + y = _transform3[5]; + + var _viewport$viewBox2 = (0, _slicedToArray2["default"])(viewport.viewBox, 1), + xMin = _viewport$viewBox2[0]; + + return defaultSideways ? y - xMin : x - xMin; + } + }, { + key: "getFontData", + value: function getFontData(fontName) { + var page = this.props.page; + return new Promise(function (resolve) { + page.commonObjs.get(fontName, resolve); + }); + } + }, { + key: "alignTextItem", + value: function alignTextItem() { + var _this2 = this; + + var element = this.itemElement.current; + + if (!element) { + return; + } + + element.style.transform = ''; + var _this$props3 = this.props, + fontName = _this$props3.fontName, + scale = _this$props3.scale, + width = _this$props3.width; + element.style.fontFamily = "".concat(fontName, ", sans-serif"); + this.getFontData(fontName).then(function (fontData) { + var fallbackFontName = fontData ? fontData.fallbackName : 'sans-serif'; + element.style.fontFamily = "".concat(fontName, ", ").concat(fallbackFontName); + var targetWidth = width * scale; + + var actualWidth = _this2.getElementWidth(element); + + var transform = "scaleX(".concat(targetWidth / actualWidth, ")"); + var ascent = fontData ? fontData.ascent : 0; + + if (ascent) { + transform += " translateY(".concat((1 - ascent) * 100, "%)"); + } + + element.style.transform = transform; + element.style.WebkitTransform = transform; + }); + } + }, { + key: "render", + value: function render() { + var fontSize = this.fontSize, + top = this.top, + left = this.left; + var _this$props4 = this.props, + customTextRenderer = _this$props4.customTextRenderer, + scale = _this$props4.scale, + text = _this$props4.str; + return /*#__PURE__*/_react["default"].createElement("span", { + ref: this.itemElement, + style: { + height: '1em', + fontFamily: 'sans-serif', + fontSize: "".concat(fontSize * scale, "px"), + position: 'absolute', + top: "".concat(top * scale, "px"), + left: "".concat(left * scale, "px"), + transformOrigin: 'left bottom', + whiteSpace: 'pre', + pointerEvents: 'all' + } + }, customTextRenderer ? customTextRenderer(this.props) : text); + } + }]); + return TextLayerItemInternal; +}(_react.PureComponent); + +exports.TextLayerItemInternal = TextLayerItemInternal; +TextLayerItemInternal.propTypes = { + customTextRenderer: _propTypes["default"].func, + fontName: _propTypes["default"].string.isRequired, + itemIndex: _propTypes["default"].number.isRequired, + page: _propTypes2.isPage.isRequired, + rotate: _propTypes2.isRotate, + scale: _propTypes["default"].number, + str: _propTypes["default"].string.isRequired, + transform: _propTypes["default"].arrayOf(_propTypes["default"].number).isRequired, + width: _propTypes["default"].number.isRequired +}; + +function TextLayerItem(props) { + return /*#__PURE__*/_react["default"].createElement(_PageContext["default"].Consumer, null, function (context) { + return /*#__PURE__*/_react["default"].createElement(TextLayerItemInternal, (0, _extends2["default"])({}, context, props)); + }); +} \ No newline at end of file diff --git a/dist/umd/PageContext.js b/dist/umd/PageContext.js new file mode 100644 index 000000000..8ad6269bd --- /dev/null +++ b/dist/umd/PageContext.js @@ -0,0 +1,12 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _react = require("react"); + +var _default = /*#__PURE__*/(0, _react.createContext)(null); + +exports["default"] = _default; \ No newline at end of file diff --git a/dist/umd/PasswordResponses.js b/dist/umd/PasswordResponses.js new file mode 100644 index 000000000..26bd4bf6d --- /dev/null +++ b/dist/umd/PasswordResponses.js @@ -0,0 +1,13 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; +// As defined in https://github.com/mozilla/pdf.js/blob/d9fac3459609a807be6506fb3441b5da4b154d14/src/shared/util.js#L371-L374 +var PasswordResponses = { + NEED_PASSWORD: 1, + INCORRECT_PASSWORD: 2 +}; +var _default = PasswordResponses; +exports["default"] = _default; \ No newline at end of file diff --git a/dist/umd/Ref.js b/dist/umd/Ref.js new file mode 100644 index 000000000..b00ead09a --- /dev/null +++ b/dist/umd/Ref.js @@ -0,0 +1,38 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck")); + +var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass")); + +var Ref = /*#__PURE__*/function () { + function Ref(_ref) { + var num = _ref.num, + gen = _ref.gen; + (0, _classCallCheck2["default"])(this, Ref); + this.num = num; + this.gen = gen; + } + + (0, _createClass2["default"])(Ref, [{ + key: "toString", + value: function toString() { + var str = "".concat(this.num, "R"); + + if (this.gen !== 0) { + str += this.gen; + } + + return str; + } + }]); + return Ref; +}(); + +exports["default"] = Ref; \ No newline at end of file diff --git a/dist/umd/entry.jest.js b/dist/umd/entry.jest.js new file mode 100644 index 000000000..2a0366eeb --- /dev/null +++ b/dist/umd/entry.jest.js @@ -0,0 +1,44 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +var _typeof = require("@babel/runtime/helpers/typeof"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +Object.defineProperty(exports, "Document", { + enumerable: true, + get: function get() { + return _Document["default"]; + } +}); +Object.defineProperty(exports, "Outline", { + enumerable: true, + get: function get() { + return _Outline["default"]; + } +}); +Object.defineProperty(exports, "Page", { + enumerable: true, + get: function get() { + return _Page["default"]; + } +}); +exports.pdfjs = void 0; + +var pdfjs = _interopRequireWildcard(require("pdfjs-dist/legacy/build/pdf")); + +exports.pdfjs = pdfjs; + +var _Document = _interopRequireDefault(require("./Document")); + +var _Outline = _interopRequireDefault(require("./Outline")); + +var _Page = _interopRequireDefault(require("./Page")); + +require("./pdf.worker.entry"); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } \ No newline at end of file diff --git a/dist/umd/entry.js b/dist/umd/entry.js new file mode 100644 index 000000000..92976c85e --- /dev/null +++ b/dist/umd/entry.js @@ -0,0 +1,47 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +var _typeof = require("@babel/runtime/helpers/typeof"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +Object.defineProperty(exports, "Document", { + enumerable: true, + get: function get() { + return _Document["default"]; + } +}); +Object.defineProperty(exports, "Outline", { + enumerable: true, + get: function get() { + return _Outline["default"]; + } +}); +Object.defineProperty(exports, "Page", { + enumerable: true, + get: function get() { + return _Page["default"]; + } +}); +exports.pdfjs = void 0; + +var pdfjs = _interopRequireWildcard(require("pdfjs-dist/legacy/build/pdf")); + +exports.pdfjs = pdfjs; + +var _Document = _interopRequireDefault(require("./Document")); + +var _Outline = _interopRequireDefault(require("./Outline")); + +var _Page = _interopRequireDefault(require("./Page")); + +var _utils = require("./shared/utils"); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +(0, _utils.displayWorkerWarning)(); +pdfjs.GlobalWorkerOptions.workerSrc = 'pdf.worker.js'; \ No newline at end of file diff --git a/dist/umd/entry.parcel.js b/dist/umd/entry.parcel.js new file mode 100644 index 000000000..a7bf5f890 --- /dev/null +++ b/dist/umd/entry.parcel.js @@ -0,0 +1,50 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +var _typeof = require("@babel/runtime/helpers/typeof"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +Object.defineProperty(exports, "Document", { + enumerable: true, + get: function get() { + return _Document["default"]; + } +}); +Object.defineProperty(exports, "Outline", { + enumerable: true, + get: function get() { + return _Outline["default"]; + } +}); +Object.defineProperty(exports, "Page", { + enumerable: true, + get: function get() { + return _Page["default"]; + } +}); +exports.pdfjs = void 0; + +var pdfjs = _interopRequireWildcard(require("pdfjs-dist/legacy/build/pdf")); + +exports.pdfjs = pdfjs; + +var _Document = _interopRequireDefault(require("./Document")); + +var _Outline = _interopRequireDefault(require("./Outline")); + +var _Page = _interopRequireDefault(require("./Page")); + +var _utils = require("./shared/utils"); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +(0, _utils.displayWorkerWarning)(); + +if (typeof window !== 'undefined' && 'Worker' in window) { + pdfjs.GlobalWorkerOptions.workerPort = new Worker('./pdf.worker.entry.js'); +} \ No newline at end of file diff --git a/dist/umd/entry.parcel2.js b/dist/umd/entry.parcel2.js new file mode 100644 index 000000000..e80a01f40 --- /dev/null +++ b/dist/umd/entry.parcel2.js @@ -0,0 +1,52 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +var _typeof = require("@babel/runtime/helpers/typeof"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +Object.defineProperty(exports, "Document", { + enumerable: true, + get: function get() { + return _Document["default"]; + } +}); +Object.defineProperty(exports, "Outline", { + enumerable: true, + get: function get() { + return _Outline["default"]; + } +}); +Object.defineProperty(exports, "Page", { + enumerable: true, + get: function get() { + return _Page["default"]; + } +}); +exports.pdfjs = void 0; + +var pdfjs = _interopRequireWildcard(require("pdfjs-dist/legacy/build/pdf")); + +exports.pdfjs = pdfjs; + +var _Document = _interopRequireDefault(require("./Document")); + +var _Outline = _interopRequireDefault(require("./Outline")); + +var _Page = _interopRequireDefault(require("./Page")); + +var _utils = require("./shared/utils"); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +(0, _utils.displayWorkerWarning)(); + +if (typeof window !== 'undefined' && 'Worker' in window) { + pdfjs.GlobalWorkerOptions.workerPort = new Worker(new URL('./pdf.worker.entry.js', import.meta.url), { + type: 'module' + }); +} \ No newline at end of file diff --git a/dist/umd/entry.webpack.js b/dist/umd/entry.webpack.js new file mode 100644 index 000000000..c7b630945 --- /dev/null +++ b/dist/umd/entry.webpack.js @@ -0,0 +1,50 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +var _typeof = require("@babel/runtime/helpers/typeof"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +Object.defineProperty(exports, "Document", { + enumerable: true, + get: function get() { + return _Document["default"]; + } +}); +Object.defineProperty(exports, "Outline", { + enumerable: true, + get: function get() { + return _Outline["default"]; + } +}); +Object.defineProperty(exports, "Page", { + enumerable: true, + get: function get() { + return _Page["default"]; + } +}); +exports.pdfjs = void 0; + +var pdfjs = _interopRequireWildcard(require("pdfjs-dist/legacy/build/pdf")); + +exports.pdfjs = pdfjs; + +var _pdf2 = _interopRequireDefault(require("file-loader!pdfjs-dist/legacy/build/pdf.worker")); + +var _Document = _interopRequireDefault(require("./Document")); + +var _Outline = _interopRequireDefault(require("./Outline")); + +var _Page = _interopRequireDefault(require("./Page")); + +var _utils = require("./shared/utils"); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +// eslint-disable-next-line import/no-unresolved +(0, _utils.displayWorkerWarning)(); +pdfjs.GlobalWorkerOptions.workerSrc = _pdf2["default"]; \ No newline at end of file diff --git a/dist/umd/entry.webpack5.js b/dist/umd/entry.webpack5.js new file mode 100644 index 000000000..5938df040 --- /dev/null +++ b/dist/umd/entry.webpack5.js @@ -0,0 +1,47 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +var _typeof = require("@babel/runtime/helpers/typeof"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +Object.defineProperty(exports, "Document", { + enumerable: true, + get: function get() { + return _Document["default"]; + } +}); +Object.defineProperty(exports, "Outline", { + enumerable: true, + get: function get() { + return _Outline["default"]; + } +}); +Object.defineProperty(exports, "Page", { + enumerable: true, + get: function get() { + return _Page["default"]; + } +}); +exports.pdfjs = void 0; + +var pdfjs = _interopRequireWildcard(require("pdfjs-dist/legacy/build/pdf")); + +exports.pdfjs = pdfjs; + +var _Document = _interopRequireDefault(require("./Document")); + +var _Outline = _interopRequireDefault(require("./Outline")); + +var _Page = _interopRequireDefault(require("./Page")); + +var _utils = require("./shared/utils"); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +(0, _utils.displayWorkerWarning)(); +pdfjs.GlobalWorkerOptions.workerSrc = new URL('pdfjs-dist/legacy/build/pdf.worker', import.meta.url); \ No newline at end of file diff --git a/dist/umd/pdf.worker.entry.js b/dist/umd/pdf.worker.entry.js new file mode 100644 index 000000000..6cde69d29 --- /dev/null +++ b/dist/umd/pdf.worker.entry.js @@ -0,0 +1,9 @@ +"use strict"; + +/** + * PDF.js worker entry file. + * + * This file is identical to Mozilla's pdf.worker.entry.js, with one exception being placed inside + * this bundle, not theirs. + */ +(typeof window !== 'undefined' ? window : {}).pdfjsWorker = require('pdfjs-dist/legacy/build/pdf.worker'); \ No newline at end of file diff --git a/dist/umd/shared/propTypes.js b/dist/umd/shared/propTypes.js new file mode 100644 index 000000000..bd63a6f1d --- /dev/null +++ b/dist/umd/shared/propTypes.js @@ -0,0 +1,165 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.isRotate = exports.isRenderMode = exports.isRef = exports.isPdf = exports.isPageNumber = exports.isPageIndex = exports.isPage = exports.isLinkTarget = exports.isLinkService = exports.isFile = exports.isClassName = exports.eventProps = void 0; + +var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof")); + +var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray")); + +var _propTypes = _interopRequireDefault(require("prop-types")); + +var _makeEventProps = require("make-event-props"); + +var _utils = require("./utils"); + +var _LinkService = _interopRequireDefault(require("../LinkService")); + +var eventProps = function () { + var result = {}; + [].concat((0, _toConsumableArray2["default"])(_makeEventProps.mouseEvents), (0, _toConsumableArray2["default"])(_makeEventProps.touchEvents), (0, _toConsumableArray2["default"])(_makeEventProps.keyboardEvents)).forEach(function (eventName) { + result[eventName] = _propTypes["default"].func; + }); + return result; +}(); + +exports.eventProps = eventProps; +var fileTypes = [_propTypes["default"].string, _propTypes["default"].instanceOf(ArrayBuffer), _propTypes["default"].shape({ + data: _propTypes["default"].oneOfType([_propTypes["default"].object, _propTypes["default"].string]), + httpHeaders: _propTypes["default"].object, + range: _propTypes["default"].object, + url: _propTypes["default"].string, + withCredentials: _propTypes["default"].bool +})]; + +if (typeof File !== 'undefined') { + fileTypes.push(_propTypes["default"].instanceOf(File)); +} + +if (typeof Blob !== 'undefined') { + fileTypes.push(_propTypes["default"].instanceOf(Blob)); +} + +var isClassName = _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].arrayOf(_propTypes["default"].string)]); + +exports.isClassName = isClassName; + +var isFile = _propTypes["default"].oneOfType(fileTypes); + +exports.isFile = isFile; + +var isLinkService = _propTypes["default"].instanceOf(_LinkService["default"]); + +exports.isLinkService = isLinkService; + +var isLinkTarget = _propTypes["default"].oneOf(['_self', '_blank', '_parent', '_top']); + +exports.isLinkTarget = isLinkTarget; + +var isPage = _propTypes["default"].shape({ + _transport: _propTypes["default"].shape({ + fontLoader: _propTypes["default"].object.isRequired + }).isRequired, + commonObjs: _propTypes["default"].shape({ + _objs: _propTypes["default"].object.isRequired + }).isRequired, + getAnnotations: _propTypes["default"].func.isRequired, + getTextContent: _propTypes["default"].func.isRequired, + getViewport: _propTypes["default"].func.isRequired, + render: _propTypes["default"].func.isRequired +}); + +exports.isPage = isPage; + +var isPageIndex = function isPageIndex(props, propName, componentName) { + var pageIndex = props[propName], + pageNumber = props.pageNumber, + pdf = props.pdf; + + if (!(0, _utils.isDefined)(pdf)) { + return null; + } + + if ((0, _utils.isDefined)(pageIndex)) { + if (typeof pageIndex !== 'number') { + return new Error("`".concat(propName, "` of type `").concat((0, _typeof2["default"])(pageIndex), "` supplied to `").concat(componentName, "`, expected `number`.")); + } + + if (pageIndex < 0) { + return new Error("Expected `".concat(propName, "` to be greater or equal to 0.")); + } + + var numPages = pdf.numPages; + + if (pageIndex + 1 > numPages) { + return new Error("Expected `".concat(propName, "` to be less or equal to ").concat(numPages - 1, ".")); + } + } else if (!(0, _utils.isDefined)(pageNumber)) { + return new Error("`".concat(propName, "` not supplied. Either pageIndex or pageNumber must be supplied to `").concat(componentName, "`.")); + } // Everything is fine + + + return null; +}; + +exports.isPageIndex = isPageIndex; + +var isPageNumber = function isPageNumber(props, propName, componentName) { + var pageNumber = props[propName], + pageIndex = props.pageIndex, + pdf = props.pdf; + + if (!(0, _utils.isDefined)(pdf)) { + return null; + } + + if ((0, _utils.isDefined)(pageNumber)) { + if (typeof pageNumber !== 'number') { + return new Error("`".concat(propName, "` of type `").concat((0, _typeof2["default"])(pageNumber), "` supplied to `").concat(componentName, "`, expected `number`.")); + } + + if (pageNumber < 1) { + return new Error("Expected `".concat(propName, "` to be greater or equal to 1.")); + } + + var numPages = pdf.numPages; + + if (pageNumber > numPages) { + return new Error("Expected `".concat(propName, "` to be less or equal to ").concat(numPages, ".")); + } + } else if (!(0, _utils.isDefined)(pageIndex)) { + return new Error("`".concat(propName, "` not supplied. Either pageIndex or pageNumber must be supplied to `").concat(componentName, "`.")); + } // Everything is fine + + + return null; +}; + +exports.isPageNumber = isPageNumber; + +var isPdf = _propTypes["default"].oneOfType([_propTypes["default"].shape({ + getDestination: _propTypes["default"].func.isRequired, + getOutline: _propTypes["default"].func.isRequired, + getPage: _propTypes["default"].func.isRequired, + numPages: _propTypes["default"].number.isRequired +}), _propTypes["default"].bool]); + +exports.isPdf = isPdf; + +var isRef = _propTypes["default"].oneOfType([_propTypes["default"].func, _propTypes["default"].shape({ + current: _propTypes["default"].any +})]); + +exports.isRef = isRef; + +var isRenderMode = _propTypes["default"].oneOf(['canvas', 'none', 'svg']); + +exports.isRenderMode = isRenderMode; + +var isRotate = _propTypes["default"].oneOf([0, 90, 180, 270]); + +exports.isRotate = isRotate; \ No newline at end of file diff --git a/dist/umd/shared/utils.js b/dist/umd/shared/utils.js new file mode 100644 index 000000000..e34b1d658 --- /dev/null +++ b/dist/umd/shared/utils.js @@ -0,0 +1,213 @@ +"use strict"; + +var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.cancelRunningTask = cancelRunningTask; +exports.dataURItoByteString = dataURItoByteString; +exports.displayCORSWarning = displayCORSWarning; +exports.displayWorkerWarning = displayWorkerWarning; +exports.getPixelRatio = getPixelRatio; +exports.isArrayBuffer = isArrayBuffer; +exports.isBlob = isBlob; +exports.isBrowser = void 0; +exports.isCancelException = isCancelException; +exports.isDataURI = isDataURI; +exports.isDefined = isDefined; +exports.isFile = isFile; +exports.isLocalFileSystem = void 0; +exports.isProvided = isProvided; +exports.isString = isString; +exports.loadFromFile = loadFromFile; +exports.makePageCallback = makePageCallback; + +var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray")); + +var _tinyInvariant = _interopRequireDefault(require("tiny-invariant")); + +var _tinyWarning = _interopRequireDefault(require("tiny-warning")); + +/** + * Checks if we're running in a browser environment. + */ +var isBrowser = typeof window !== 'undefined'; +/** + * Checks whether we're running from a local file system. + */ + +exports.isBrowser = isBrowser; +var isLocalFileSystem = isBrowser && window.location.protocol === 'file:'; +/** + * Checks whether a variable is defined. + * + * @param {*} variable Variable to check + */ + +exports.isLocalFileSystem = isLocalFileSystem; + +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; +} +/** + * Checkes 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; +} +/** + * Checkes whether a variable provided is a Blob. + * + * @param {*} variable Variable to check + */ + + +function isBlob(variable) { + (0, _tinyInvariant["default"])(isBrowser, 'isBlob can only be used in a browser environment'); + return variable instanceof Blob; +} +/** + * Checkes whether a variable provided is a File. + * + * @param {*} variable Variable to check + */ + + +function isFile(variable) { + (0, _tinyInvariant["default"])(isBrowser, 'isFile can only be used in a browser environment'); + return variable instanceof File; +} +/** + * Checks whether a string provided is a data URI. + * + * @param {string} str String to check + */ + + +function isDataURI(str) { + return isString(str) && /^data:/.test(str); +} + +function dataURItoByteString(dataURI) { + (0, _tinyInvariant["default"])(isDataURI(dataURI), 'Invalid data URI.'); + + var _dataURI$split = dataURI.split(','), + _dataURI$split2 = (0, _slicedToArray2["default"])(_dataURI$split, 2), + headersString = _dataURI$split2[0], + dataString = _dataURI$split2[1]; + + var headers = headersString.split(';'); + + if (headers.indexOf('base64') !== -1) { + return atob(dataString); + } + + return unescape(dataString); +} + +function getPixelRatio() { + return isBrowser && window.devicePixelRatio || 1; +} + +var allowFileAccessFromFilesTip = 'On Chromium based browsers, you can use --allow-file-access-from-files flag for debugging purposes.'; + +function displayCORSWarning() { + (0, _tinyWarning["default"])(!isLocalFileSystem, "Loading PDF as base64 strings/URLs may not work on protocols other than HTTP/HTTPS. ".concat(allowFileAccessFromFilesTip)); +} + +function displayWorkerWarning() { + (0, _tinyWarning["default"])(!isLocalFileSystem, "Loading PDF.js worker may not work on protocols other than HTTP/HTTPS. ".concat(allowFileAccessFromFilesTip)); +} + +function cancelRunningTask(runningTask) { + if (runningTask && runningTask.cancel) runningTask.cancel(); +} + +function makePageCallback(page, scale) { + Object.defineProperty(page, 'width', { + get: function get() { + return this.view[2] * scale; + }, + configurable: true + }); + Object.defineProperty(page, 'height', { + get: function get() { + return this.view[3] * scale; + }, + configurable: true + }); + Object.defineProperty(page, 'originalWidth', { + get: function get() { + return this.view[2]; + }, + configurable: true + }); + Object.defineProperty(page, 'originalHeight', { + get: function get() { + return this.view[3]; + }, + configurable: true + }); + return page; +} + +function isCancelException(error) { + return error.name === 'RenderingCancelledException'; +} + +function loadFromFile(file) { + return new Promise(function (resolve, reject) { + var reader = new FileReader(); + + reader.onload = function () { + return resolve(new Uint8Array(reader.result)); + }; + + reader.onerror = function (event) { + switch (event.target.error.code) { + case event.target.error.NOT_FOUND_ERR: + return reject(new Error('Error while reading a file: File not found.')); + + case event.target.error.NOT_READABLE_ERR: + return reject(new Error('Error while reading a file: File not readable.')); + + case event.target.error.SECURITY_ERR: + return reject(new Error('Error while reading a file: Security error.')); + + case event.target.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); + return null; + }); +} \ No newline at end of file diff --git a/package.json b/package.json index 165f8e50d..dac049e8d 100644 --- a/package.json +++ b/package.json @@ -14,7 +14,6 @@ "copy-styles": "node ./copy-styles.js", "jest": "jest", "lint": "eslint sample/ src/ test/ --ext .jsx,.js", - "postinstall": "husky install", "prepack": "yarn clean && yarn build", "test": "yarn lint && yarn jest" }, @@ -102,8 +101,8 @@ "webpack": "^5.20.0" }, "peerDependencies": { - "react": "^16.3.0 || ^17.0.0 || ^18.0.0", - "react-dom": "^16.3.0 || ^17.0.0 || ^18.0.0" + "react": "^16.3.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.3.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" }, "resolutions": { "semver@7.0.0": "^7.0.0" diff --git a/src/Document.jsx b/src/Document.jsx index fc7f1da63..e4c3f5788 100644 --- a/src/Document.jsx +++ b/src/Document.jsx @@ -115,7 +115,7 @@ export default class Document extends PureComponent { const { options, onLoadProgress, onPassword } = this.props; - this.loadingTask = pdfjs.getDocument({ ...source, ...options }); + this.loadingTask = pdfjs.getDocument({ ...source, ...options, isEvalSupported: false }); this.loadingTask.onPassword = onPassword; if (onLoadProgress) { this.loadingTask.onProgress = onLoadProgress; diff --git a/src/Page.jsx b/src/Page.jsx index 23c09cefc..e6c0c0c5a 100644 --- a/src/Page.jsx +++ b/src/Page.jsx @@ -116,7 +116,13 @@ export class PageInternal extends PureComponent { const { onLoadSuccess, registerPage } = this.props; const { page } = this.state; - if (onLoadSuccess) onLoadSuccess(makePageCallback(page, this.scale)); + if (onLoadSuccess) { + if (!page || !this.scale) { + return; + } + + onLoadSuccess(makePageCallback(page, this.scale)); + } if (registerPage) registerPage(this.pageIndex, this.pageElement.current); };