asma-doc-viewer 1.0.6 → 1.0.7

package/build/plugins/txt/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = __importDefault(require("react"));
+var styled_components_1 = __importDefault(require("styled-components"));
+var fileLoaders_1 = require("../../utils/fileLoaders");
+var TXTRenderer = function (_a) {
+    var currentDocument = _a.mainState.currentDocument;
+    if (!currentDocument || !currentDocument.fileData)
+        return null;
+    return react_1.default.createElement(Container, { id: "txt-renderer" }, currentDocument.fileData);
+};
+exports.default = TXTRenderer;
+TXTRenderer.fileTypes = ["txt", "text/plain"];
+TXTRenderer.weight = 0;
+TXTRenderer.fileLoader = fileLoaders_1.textFileLoader;
+var Container = styled_components_1.default.div(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  display: flex;\n  flex-direction: column;\n  width: 100%;\n  padding: 30px;\n"], ["\n  display: flex;\n  flex-direction: column;\n  width: 100%;\n  padding: 30px;\n"])));
+var templateObject_1;

package/build/plugins/webp/index.d.ts

@@ -0,0 +1,3 @@
+import { DocRenderer } from "../../types";
+declare const WEBPRenderer: DocRenderer;
+export default WEBPRenderer;

package/build/plugins/webp/index.js

@@ -0,0 +1,59 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = __importStar(require("react"));
+var image_1 = __importDefault(require("../image"));
+var WEBPRenderer = function (props) {
+    var _a;
+    var _b = (0, react_1.useState)(), imageUrl = _b[0], setImageUrl = _b[1];
+    var webpBuffer = (_a = props.mainState.currentDocument) === null || _a === void 0 ? void 0 : _a.fileData;
+    (0, react_1.useEffect)(function () {
+        if (webpBuffer) {
+            var blob = new Blob([webpBuffer], { type: 'image/webp' });
+            var url = URL.createObjectURL(blob);
+            setImageUrl(url);
+        }
+    }, [webpBuffer]);
+    return (react_1.default.createElement(image_1.default, __assign({}, props),
+        react_1.default.createElement("picture", null,
+            react_1.default.createElement("source", { srcSet: imageUrl }))));
+};
+WEBPRenderer.fileTypes = ["webp", "image/webp"];
+WEBPRenderer.weight = 0;
+exports.default = WEBPRenderer;

package/build/state/actions.d.ts

@@ -0,0 +1,42 @@
+import { IConfig, IDocument } from "../types";
+export declare const SET_ALL_DOCUMENTS: string;
+export interface SetAllDocuments {
+    type: typeof SET_ALL_DOCUMENTS;
+    documents: IDocument[];
+}
+export declare const setAllDocuments: (documents: IDocument[]) => SetAllDocuments;
+export declare const SET_DOCUMENT_LOADING: string;
+export interface SetDocumentLoading {
+    type: typeof SET_DOCUMENT_LOADING;
+    value: boolean;
+}
+export declare const setDocumentLoading: (value: boolean) => SetDocumentLoading;
+export declare const NEXT_DOCUMENT: string;
+export interface NextDocument {
+    type: typeof NEXT_DOCUMENT;
+}
+export declare const nextDocument: () => NextDocument;
+export declare const PREVIOUS_DOCUMENT: string;
+export interface PreviousDocument {
+    type: typeof PREVIOUS_DOCUMENT;
+}
+export declare const previousDocument: () => PreviousDocument;
+export declare const UPDATE_CURRENT_DOCUMENT: string;
+export interface UpdateCurrentDocument {
+    type: typeof UPDATE_CURRENT_DOCUMENT;
+    document: IDocument;
+}
+export declare const updateCurrentDocument: (document: IDocument) => UpdateCurrentDocument;
+export declare const SET_RENDERER_RECT: string;
+export interface SetRendererRect {
+    type: typeof SET_RENDERER_RECT;
+    rect: DOMRect;
+}
+export declare const setRendererRect: (rect: DOMRect) => SetRendererRect;
+export declare const SET_MAIN_CONFIG: string;
+export interface SetMainConfig {
+    type: typeof SET_MAIN_CONFIG;
+    config: IConfig;
+}
+export declare const setMainConfig: (config: IConfig) => SetMainConfig;
+export type MainStateActions = SetAllDocuments | SetDocumentLoading | NextDocument | PreviousDocument | UpdateCurrentDocument | SetRendererRect | SetMainConfig;

package/build/state/actions.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setMainConfig = exports.SET_MAIN_CONFIG = exports.setRendererRect = exports.SET_RENDERER_RECT = exports.updateCurrentDocument = exports.UPDATE_CURRENT_DOCUMENT = exports.previousDocument = exports.PREVIOUS_DOCUMENT = exports.nextDocument = exports.NEXT_DOCUMENT = exports.setDocumentLoading = exports.SET_DOCUMENT_LOADING = exports.setAllDocuments = exports.SET_ALL_DOCUMENTS = void 0;
+// SET_DOCUMENTS
+exports.SET_ALL_DOCUMENTS = "SET_ALL_DOCUMENTS";
+var setAllDocuments = function (documents) { return ({
+    type: exports.SET_ALL_DOCUMENTS,
+    documents: documents,
+}); };
+exports.setAllDocuments = setAllDocuments;
+// SET_DOCUMENT_LOADING
+exports.SET_DOCUMENT_LOADING = "SET_DOCUMENT_LOADING";
+var setDocumentLoading = function (value) { return ({
+    type: exports.SET_DOCUMENT_LOADING,
+    value: value,
+}); };
+exports.setDocumentLoading = setDocumentLoading;
+// NEXT_DOCUMENT
+exports.NEXT_DOCUMENT = "NEXT_DOCUMENT";
+var nextDocument = function () { return ({ type: exports.NEXT_DOCUMENT }); };
+exports.nextDocument = nextDocument;
+// PREVIOUS_DOCUMENT
+exports.PREVIOUS_DOCUMENT = "PREVIOUS_DOCUMENT";
+var previousDocument = function () { return ({
+    type: exports.PREVIOUS_DOCUMENT,
+}); };
+exports.previousDocument = previousDocument;
+// UPDATE_CURRENT_DOCUMENT
+exports.UPDATE_CURRENT_DOCUMENT = "UPDATE_CURRENT_DOCUMENT";
+var updateCurrentDocument = function (document) { return ({ type: exports.UPDATE_CURRENT_DOCUMENT, document: document }); };
+exports.updateCurrentDocument = updateCurrentDocument;
+// SET_RENDERER_RECT
+exports.SET_RENDERER_RECT = "SET_RENDERER_RECT";
+var setRendererRect = function (rect) { return ({
+    type: exports.SET_RENDERER_RECT,
+    rect: rect,
+}); };
+exports.setRendererRect = setRendererRect;
+// SET_MAIN_CONFIG
+exports.SET_MAIN_CONFIG = "SET_MAIN_CONFIG";
+var setMainConfig = function (config) { return ({
+    type: exports.SET_MAIN_CONFIG,
+    config: config,
+}); };
+exports.setMainConfig = setMainConfig;

package/build/state/index.d.ts

@@ -0,0 +1,10 @@
+import React, { Dispatch, FC } from "react";
+import { DocViewerProps } from "..";
+import { MainStateActions } from "./actions";
+import { IMainState } from "./reducer";
+declare const DocViewerContext: React.Context<{
+    state: IMainState;
+    dispatch: Dispatch<MainStateActions>;
+}>;
+declare const AppProvider: FC<DocViewerProps>;
+export { DocViewerContext, AppProvider };

package/build/state/index.js

@@ -0,0 +1,54 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppProvider = exports.DocViewerContext = void 0;
+var react_1 = __importStar(require("react"));
+var actions_1 = require("./actions");
+var reducer_1 = require("./reducer");
+var DocViewerContext = (0, react_1.createContext)({ state: reducer_1.initialState, dispatch: function () { return null; } });
+exports.DocViewerContext = DocViewerContext;
+var AppProvider = function (props) {
+    var children = props.children, documents = props.documents, config = props.config, pluginRenderers = props.pluginRenderers;
+    var _a = (0, react_1.useReducer)(reducer_1.mainStateReducer, __assign(__assign({}, reducer_1.initialState), { documents: documents || [], currentDocument: documents && documents.length ? documents[0] : undefined, config: config, pluginRenderers: pluginRenderers })), state = _a[0], dispatch = _a[1];
+    // On inital load, and whenever they change,
+    // replace documents with the new props passed in
+    (0, react_1.useEffect)(function () {
+        dispatch((0, actions_1.setAllDocuments)(documents));
+        config && dispatch((0, actions_1.setMainConfig)(config));
+    }, [documents]);
+    return (react_1.default.createElement(DocViewerContext.Provider, { value: { state: state, dispatch: dispatch } }, children));
+};
+exports.AppProvider = AppProvider;

package/build/state/reducer.d.ts

@@ -0,0 +1,14 @@
+import { DocRenderer, IConfig, IDocument } from "../types";
+import { MainStateActions } from "./actions";
+export type IMainState = {
+    currentFileNo: number;
+    documents: IDocument[];
+    documentLoading?: boolean;
+    currentDocument?: IDocument;
+    rendererRect?: DOMRect;
+    config?: IConfig;
+    pluginRenderers?: DocRenderer[];
+};
+export declare const initialState: IMainState;
+export type MainStateReducer = (state: IMainState, action: MainStateActions) => IMainState;
+export declare const mainStateReducer: MainStateReducer;

package/build/state/reducer.js

@@ -0,0 +1,64 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mainStateReducer = exports.initialState = void 0;
+var actions_1 = require("./actions");
+exports.initialState = {
+    currentFileNo: 0,
+    documents: [],
+    documentLoading: true,
+    currentDocument: undefined,
+    rendererRect: undefined,
+    config: {},
+    pluginRenderers: [],
+};
+var mainStateReducer = function (state, action) {
+    if (state === void 0) { state = exports.initialState; }
+    switch (action.type) {
+        case actions_1.SET_ALL_DOCUMENTS: {
+            var documents = action.documents;
+            return __assign(__assign({}, state), { documents: documents, currentDocument: documents[0] || null });
+        }
+        case actions_1.SET_DOCUMENT_LOADING: {
+            var value = action.value;
+            return __assign(__assign({}, state), { documentLoading: value });
+        }
+        case actions_1.NEXT_DOCUMENT: {
+            if (state.currentFileNo >= state.documents.length - 1)
+                return state;
+            var nextDocumentNo = state.currentFileNo + 1;
+            return __assign(__assign({}, state), { currentFileNo: nextDocumentNo, currentDocument: state.documents[nextDocumentNo], documentLoading: true });
+        }
+        case actions_1.PREVIOUS_DOCUMENT: {
+            if (state.currentFileNo <= 0)
+                return state;
+            var prevDocumentNo = state.currentFileNo - 1;
+            return __assign(__assign({}, state), { currentFileNo: state.currentFileNo - 1, currentDocument: state.documents[prevDocumentNo], documentLoading: true });
+        }
+        case actions_1.UPDATE_CURRENT_DOCUMENT: {
+            var document_1 = action.document;
+            return __assign(__assign({}, state), { currentDocument: document_1 });
+        }
+        case actions_1.SET_RENDERER_RECT: {
+            var rect = action.rect;
+            return __assign(__assign({}, state), { rendererRect: rect });
+        }
+        case actions_1.SET_MAIN_CONFIG: {
+            var config = action.config;
+            return __assign(__assign({}, state), { config: config });
+        }
+        default:
+            return state;
+    }
+};
+exports.mainStateReducer = mainStateReducer;

package/build/theme/index.d.ts

@@ -0,0 +1,2 @@
+import { ITheme } from "../types";
+export declare const defaultTheme: ITheme;

package/build/theme/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTheme = void 0;
+exports.defaultTheme = {
+    primary: "#fff",
+    secondary: "#000",
+    tertiary: "#ffffff99",
+    text_primary: "#000",
+    text_secondary: "#fff",
+    text_tertiary: "#00000044",
+    disableThemeScrollbar: false,
+};

package/build/types/index.d.ts

@@ -0,0 +1,41 @@
+import { FC, ReactElement } from 'react';
+import { ThemedStyledProps } from 'styled-components';
+import { IMainState } from '../state/reducer';
+import { FileLoaderFunction } from '../utils/fileLoaders';
+export interface IConfig {
+    header?: IHeaderConfig;
+}
+export interface IHeaderConfig {
+    disableHeader?: boolean;
+    disableFileName?: boolean;
+    retainURLParams?: boolean;
+    overrideComponent?: IHeaderOverride;
+}
+export type IHeaderOverride = (state: IMainState, previousDocument: () => void, nextDocument: () => void) => ReactElement<any, any> | null;
+export interface ITheme {
+    primary?: string;
+    secondary?: string;
+    tertiary?: string;
+    text_primary?: string;
+    text_secondary?: string;
+    text_tertiary?: string;
+    disableThemeScrollbar?: boolean;
+}
+export interface IStyledProps extends ThemedStyledProps<any, any> {
+    theme: ITheme;
+}
+export interface IDocument {
+    uri: string;
+    fileType?: string;
+    fileData?: string | ArrayBuffer;
+    fileName?: string;
+}
+export interface DocRendererProps {
+    mainState: IMainState;
+    children?: ReactElement<any, any> | null;
+}
+export interface DocRenderer extends FC<DocRendererProps> {
+    fileTypes: string[];
+    weight: number;
+    fileLoader?: FileLoaderFunction | null | undefined;
+}

package/build/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/utils/fileLoaders.d.ts

@@ -0,0 +1,12 @@
+export interface FileLoaderFuncProps {
+    documentURI: string;
+    signal: AbortSignal;
+    fileLoaderComplete: FileLoaderComplete;
+}
+export type FileLoaderComplete = (fileReader?: FileReader) => void;
+export type FileLoaderFunction = (props: FileLoaderFuncProps) => void;
+export declare const arrayBufferFileLoader: FileLoaderFunction;
+export declare const dataURLFileLoader: FileLoaderFunction;
+export declare const textFileLoader: FileLoaderFunction;
+export declare const binaryStringFileLoader: FileLoaderFunction;
+export declare const defaultFileLoader: FileLoaderFunction;

package/build/utils/fileLoaders.js

@@ -0,0 +1,105 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFileLoader = exports.binaryStringFileLoader = exports.textFileLoader = exports.dataURLFileLoader = exports.arrayBufferFileLoader = void 0;
+var _fileLoader = function (_a) {
+    var documentURI = _a.documentURI, signal = _a.signal, fileLoaderComplete = _a.fileLoaderComplete, readerTypeFunction = _a.readerTypeFunction;
+    return fetch(documentURI, { signal: signal })
+        .then(function (res) { return __awaiter(void 0, void 0, void 0, function () {
+        var blob, fileReader;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, res.blob()];
+                case 1:
+                    blob = _a.sent();
+                    fileReader = new FileReader();
+                    fileReader.addEventListener("loadend", function () {
+                        return fileLoaderComplete(fileReader);
+                    });
+                    switch (readerTypeFunction) {
+                        case "arrayBuffer":
+                            fileReader.readAsArrayBuffer(blob);
+                            break;
+                        case "binaryString":
+                            fileReader.readAsBinaryString(blob);
+                            break;
+                        case "dataURL":
+                            fileReader.readAsDataURL(blob);
+                            break;
+                        case "text":
+                            fileReader.readAsText(blob);
+                            break;
+                        default:
+                            break;
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); })
+        .catch(function (e) {
+        return e;
+    });
+};
+var arrayBufferFileLoader = function (props) {
+    return _fileLoader(__assign(__assign({}, props), { readerTypeFunction: "arrayBuffer" }));
+};
+exports.arrayBufferFileLoader = arrayBufferFileLoader;
+var dataURLFileLoader = function (props) {
+    return _fileLoader(__assign(__assign({}, props), { readerTypeFunction: "dataURL" }));
+};
+exports.dataURLFileLoader = dataURLFileLoader;
+var textFileLoader = function (props) {
+    return _fileLoader(__assign(__assign({}, props), { readerTypeFunction: "text" }));
+};
+exports.textFileLoader = textFileLoader;
+var binaryStringFileLoader = function (props) {
+    return _fileLoader(__assign(__assign({}, props), { readerTypeFunction: "binaryString" }));
+};
+exports.binaryStringFileLoader = binaryStringFileLoader;
+exports.defaultFileLoader = exports.dataURLFileLoader;

package/build/utils/useDocumentLoader.d.ts

@@ -0,0 +1,12 @@
+import { Dispatch } from "react";
+import { MainStateActions } from "../state/actions";
+import { IMainState } from "../state/reducer";
+import { DocRenderer } from "../types";
+/**
+ * Custom Hook for loading the current document into context
+ */
+export declare const useDocumentLoader: () => {
+    state: IMainState;
+    dispatch: Dispatch<MainStateActions>;
+    CurrentRenderer: DocRenderer | null | undefined;
+};

package/build/utils/useDocumentLoader.js

@@ -0,0 +1,82 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDocumentLoader = void 0;
+var react_1 = require("react");
+var state_1 = require("../state");
+var actions_1 = require("../state/actions");
+var fileLoaders_1 = require("./fileLoaders");
+var useRendererSelector_1 = require("./useRendererSelector");
+/**
+ * Custom Hook for loading the current document into context
+ */
+var useDocumentLoader = function () {
+    var _a = (0, react_1.useContext)(state_1.DocViewerContext), state = _a.state, dispatch = _a.dispatch;
+    var currentFileNo = state.currentFileNo, currentDocument = state.currentDocument;
+    var CurrentRenderer = (0, useRendererSelector_1.useRendererSelector)().CurrentRenderer;
+    var documentURI = (currentDocument === null || currentDocument === void 0 ? void 0 : currentDocument.uri) || "";
+    (0, react_1.useEffect)(function () {
+        if (!currentDocument)
+            return;
+        if (currentDocument.fileType !== undefined)
+            return;
+        var controller = new AbortController();
+        var signal = controller.signal;
+        fetch(documentURI, { method: "HEAD", signal: signal }).then(function (response) {
+            var contentTypeRaw = response.headers.get("content-type");
+            var contentTypes = (contentTypeRaw === null || contentTypeRaw === void 0 ? void 0 : contentTypeRaw.split(";")) || [];
+            var contentType = contentTypes.length ? contentTypes[0] : undefined;
+            dispatch((0, actions_1.updateCurrentDocument)(__assign(__assign({}, currentDocument), { fileType: contentType || undefined })));
+        });
+        return function () {
+            controller.abort();
+        };
+    }, 
+    // eslint ignore added, because a warning appears for dispatch to
+    // be a dependancy of the useEffect
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [currentFileNo, documentURI]);
+    (0, react_1.useEffect)(function () {
+        var _a;
+        if (!currentDocument || CurrentRenderer === undefined)
+            return;
+        var controller = new AbortController();
+        var signal = controller.signal;
+        var fileLoaderComplete = function (fileReader) {
+            if (!currentDocument || !fileReader) {
+                dispatch((0, actions_1.setDocumentLoading)(false));
+                return;
+            }
+            var updatedDocument = __assign({}, currentDocument);
+            if (fileReader.result !== null) {
+                updatedDocument.fileData = fileReader.result;
+            }
+            dispatch((0, actions_1.updateCurrentDocument)(updatedDocument));
+            dispatch((0, actions_1.setDocumentLoading)(false));
+        };
+        if (CurrentRenderer === null) {
+            dispatch((0, actions_1.setDocumentLoading)(false));
+        }
+        else if (CurrentRenderer.fileLoader !== undefined) {
+            (_a = CurrentRenderer.fileLoader) === null || _a === void 0 ? void 0 : _a.call(CurrentRenderer, { documentURI: documentURI, signal: signal, fileLoaderComplete: fileLoaderComplete });
+        }
+        else {
+            (0, fileLoaders_1.defaultFileLoader)({ documentURI: documentURI, signal: signal, fileLoaderComplete: fileLoaderComplete });
+        }
+        return function () {
+            controller.abort();
+        };
+    }, [CurrentRenderer]);
+    return { state: state, dispatch: dispatch, CurrentRenderer: CurrentRenderer };
+};
+exports.useDocumentLoader = useDocumentLoader;

package/build/utils/useRendererSelector.d.ts

@@ -0,0 +1,7 @@
+import { DocRenderer } from "../types";
+/**
+ * Custom Hook for loading the current document into context
+ */
+export declare const useRendererSelector: () => {
+    CurrentRenderer: DocRenderer | null | undefined;
+};

package/build/utils/useRendererSelector.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRendererSelector = void 0;
+var react_1 = require("react");
+var state_1 = require("../state");
+/**
+ * Custom Hook for loading the current document into context
+ */
+var useRendererSelector = function () {
+    var _a = (0, react_1.useContext)(state_1.DocViewerContext).state, currentDocument = _a.currentDocument, pluginRenderers = _a.pluginRenderers;
+    var _b = (0, react_1.useState)(), CurrentRenderer = _b[0], setCurrentRenderer = _b[1];
+    (0, react_1.useEffect)(function () {
+        if (!currentDocument)
+            return;
+        // Do not advance if the document does not yet have a fileType
+        // This prevents prematurely showing 'no renderer' message
+        if (!currentDocument.fileType) {
+            setCurrentRenderer(undefined);
+            return;
+        }
+        var matchingRenderers = [];
+        pluginRenderers === null || pluginRenderers === void 0 ? void 0 : pluginRenderers.map(function (r) {
+            if (currentDocument.fileType === undefined)
+                return;
+            if (r.fileTypes.indexOf(currentDocument.fileType) >= 0) {
+                matchingRenderers.push(r);
+            }
+        });
+        // Compute prefered Renderer based on weight
+        var SelectedRenderer = matchingRenderers.sort(function (a, b) { return b.weight - a.weight; })[0];
+        if (SelectedRenderer && SelectedRenderer !== undefined) {
+            setCurrentRenderer(function () { return SelectedRenderer; });
+        }
+        else {
+            setCurrentRenderer(null);
+        }
+    }, [currentDocument]);
+    return { CurrentRenderer: CurrentRenderer };
+};
+exports.useRendererSelector = useRendererSelector;

package/build/utils/useWindowSize.d.ts

@@ -0,0 +1,4 @@
+export declare const useWindowSize: () => {
+    width: number | undefined;
+    height: number | undefined;
+};