@legalplace/prerenderx 2.0.0

package/.eslintrc

@@ -0,0 +1,52 @@
+{
+  "env": {
+    "browser": true,
+    "commonjs": true,
+    "es6": true,
+    "jest": true,
+    "node": true
+  },
+
+  "extends": [
+    "airbnb-base",
+    "plugin:prettier/recommended"
+  ],
+
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "project": "./tsconfig.eslint.json"
+  },
+
+  "plugins": [
+   "prettier", "@typescript-eslint"
+  ],
+
+  "rules": {
+    "prettier/prettier": ["error"],
+    "no-unused-vars": "off",
+    "@typescript-eslint/no-unused-vars": ["error", {
+      "vars": "all",
+      "args": "after-used",
+      "ignoreRestSiblings": false
+    }],
+    "import/no-extraneous-dependencies": ["error", {
+      "devDependencies": true
+    }],
+    "no-continue": 0,
+    "class-methods-use-this": 0,
+    "no-underscore-dangle": 0,
+    "import/prefer-default-export": "warn",
+    "camelcase": "error",
+    "no-undef": 0,
+    "no-dupe-class-members": "off"
+  },
+
+
+  "settings": {
+    "import/resolver": {
+      "node": {
+        "extensions": [".js", ".jsx", ".ts", ".tsx"]
+      }
+    }
+  }
+}

package/.gitlab-ci.yml

@@ -0,0 +1,28 @@
+image: node:11-alpine
+
+
+stages:
+  - deploy
+
+before_script:
+- export PATH=$PATH:./node_modules/.bin/
+
+variables: 
+  DOCKER_DRIVER: overlay2
+
+publish:
+  image: node:11-alpine
+  stage: deploy
+  except:
+    variables:
+      - $CI_COMMIT_MESSAGE =~ /skip-publish/
+  script:
+    - echo -e "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > ~/.npmrc
+    - yarn install
+    - yarn build
+    - npm publish
+    - echo "PUBLISHED SUCCESSFULLY"
+  environment:
+    name: development
+  only:
+  - master

package/.vscode/settings.json

@@ -0,0 +1,22 @@
+{
+  "eslint.enable": true,
+  "eslint.autoFixOnSave": true,
+  "editor.tabSize": 2,
+  "eslint.validate": [
+    "javascript",
+    {
+      "autoFix": true,
+      "language": "typescript"
+    }
+  ],
+  "eslint.options": {
+    "extensions": [".ts", ".js"]
+  },
+  "files.autoSave": "off",
+  "editor.formatOnSave": false,
+  "editor.formatOnType": true,
+  "prettier.singleQuote": true,
+  "eslint.packageManager": "yarn",
+  "eslint.quiet": true,
+  "typescript.tsdk": "node_modules/typescript/lib",
+}

package/.vscode/tasks.json

@@ -0,0 +1,24 @@
+{
+  // See https://go.microsoft.com/fwlink/?LinkId=733558 
+  // for the documentation about the tasks.json format
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "type": "npm",
+      "script": "lint",
+      "problemMatcher": [
+        "$eslint-stylish",
+        "$tsc"
+      ]
+    },
+    {
+      "type": "typescript",
+      "tsconfig": "tsconfig.json",
+      "option": "watch",
+      "problemMatcher": [
+        "$tsc-watch"
+      ],
+      "group": "build"
+    }
+  ]
+}

package/README.md

@@ -0,0 +1,27 @@
+# PrerenderX v1.0.0
+
+# Install
+```
+yarn add git+https://git.legalplace.eu/legalplace/prerenderx.git#1.0.0
+```
+
+# Usage
+```javascript
+import { Prerender } from 'prerenderx';
+
+const model = {}; // Your v3 (non final) model
+const ovc = {options: {}, variables: {}}; // Your OVC
+
+const prerender = new Prerender(modelV3, ovc);
+
+const documents = prerender.getDocuments();
+```
+
+Variable `documents` will now contain an object containing all documents and their respective outputs
+```
+{
+  'main': [..., 'some output', ...],
+  'some secondary document': [..., 'some other output', ...]
+  ...
+}
+```

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import Prerender from "./libs/Prerender";
+export { Prerender };

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Prerender_1 = __importDefault(require("./libs/Prerender"));
+exports.Prerender = Prerender_1.default;

package/dist/libs/ConditionsRunner.d.ts

@@ -0,0 +1,27 @@
+import { Types } from "@legalplace/referencesparser";
+import { ConditionV3 } from "@legalplace/models-v3-types";
+declare type OVC_TYPE = {
+    options: {
+        [key: string]: boolean[];
+    };
+    variables: {
+        [key: string]: (number | string)[];
+    };
+};
+declare class ConditionsRunner {
+    private references;
+    private ovc;
+    constructor(references: Types.ReferencesType, ovc: OVC_TYPE);
+    private populateData;
+    isOptionRelatedToOption(optionA: number, optionB: number): boolean;
+    isVariableRelatedToOption(variableId: number, optionId: number): boolean;
+    isVariableRelatedToVariable(variableA: number, variableB: number): boolean;
+    executeCondition(condition: {
+        dataMap: {
+            o: number[];
+            v: number[];
+        };
+        conditions: ConditionV3;
+    }, id: number, index: number, conditionType: "options" | "optionValidator" | "variables" | "prefillers" | "variableValidator" | "sections" | "documents"): any;
+}
+export default ConditionsRunner;

package/dist/libs/ConditionsRunner.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var lplogic_1 = __importDefault(require("@legalplace/lplogic"));
+var ConditionsRunner = (function () {
+    function ConditionsRunner(references, ovc) {
+        this.references = references;
+        this.ovc = ovc;
+    }
+    ConditionsRunner.prototype.populateData = function (id, index, dataMap, withRelations) {
+        var _this = this;
+        if (withRelations === void 0) { withRelations = true; }
+        var data = {
+            o: {},
+            v: {}
+        };
+        dataMap.o.forEach(function (currentOptionId) {
+            var value = _this.ovc.options[currentOptionId];
+            var currentOptionParents = _this.references.relations.options[currentOptionId].parents;
+            var currentOptionRoot = currentOptionParents[currentOptionParents.length - 1];
+            var currentOptionRootRelations = currentOptionRoot
+                ? _this.references.relations.options[currentOptionId]
+                : undefined;
+            if (withRelations === true && currentOptionRootRelations) {
+                if (id === currentOptionId ||
+                    currentOptionRootRelations.children.options.includes(id) ||
+                    currentOptionRootRelations.dependants.includes(id))
+                    value = [value[index]];
+            }
+            data.o[currentOptionId] = value;
+        });
+        dataMap.v.forEach(function (currentVariableId) {
+            var variableReference = _this.references.variables[currentVariableId];
+            var value = _this.ovc.variables[currentVariableId];
+            var variableParents = _this.references.relations.variables[currentVariableId].parents;
+            var currentOptionId = variableParents[0];
+            var currentOptionParents = _this.references.relations.options[currentOptionId].parents;
+            var currentOptionRoot = currentOptionParents[currentOptionParents.length - 1];
+            var currentOptionRootRelations = currentOptionRoot
+                ? _this.references.relations.options[currentOptionId]
+                : undefined;
+            if (withRelations === true && currentOptionRootRelations) {
+                if (currentOptionRootRelations.children.options.includes(currentOptionId) ||
+                    currentOptionRootRelations.dependants.includes(currentOptionId)) {
+                    value = [value[index]];
+                }
+            }
+            var dataValue = value.map(function (v) {
+                return v === null ? "" : v;
+            });
+            if (variableReference.type === "number") {
+                dataValue = dataValue.map(function (v) {
+                    return typeof v === "number" ? v : parseFloat(v);
+                });
+            }
+            data.v[currentVariableId] = dataValue;
+        });
+        return data;
+    };
+    ConditionsRunner.prototype.isOptionRelatedToOption = function (optionA, optionB) {
+        var OptionBParents = this.references.relations.options[optionB].parents;
+        var OptionBRoot = OptionBParents[OptionBParents.length - 1];
+        var OptionBRootRelations = OptionBRoot
+            ? this.references.relations.options[OptionBRoot]
+            : undefined;
+        if (OptionBRootRelations) {
+            if (optionA === optionB ||
+                OptionBRootRelations.children.options.includes(optionA) ||
+                OptionBRootRelations.dependants.includes(optionA)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    ConditionsRunner.prototype.isVariableRelatedToOption = function (variableId, optionId) {
+        var variableParentId = this.references.relations.variables[variableId]
+            .parents[0];
+        var optionParents = this.references.relations.options[variableParentId]
+            .parents;
+        var optionRoot = optionParents[optionParents.length - 1];
+        var optionRootRelations = optionRoot
+            ? this.references.relations.options[optionRoot]
+            : undefined;
+        if (optionRootRelations) {
+            if (optionRootRelations.children.options.includes(optionId) ||
+                optionRootRelations.dependants.includes(optionId)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    ConditionsRunner.prototype.isVariableRelatedToVariable = function (variableA, variableB) {
+        var optionA = this.references.relations.variables[variableA].parents[0];
+        var optionB = this.references.relations.variables[variableB].parents[0];
+        var OptionBParents = this.references.relations.options[optionB].parents;
+        var OptionBRoot = OptionBParents[OptionBParents.length - 1];
+        var OptionBRootRelations = OptionBRoot
+            ? this.references.relations.options[OptionBRoot]
+            : undefined;
+        if (OptionBRootRelations) {
+            if (optionA === optionB ||
+                OptionBRootRelations.children.options.includes(optionA) ||
+                OptionBRootRelations.dependants.includes(optionA)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    ConditionsRunner.prototype.executeCondition = function (condition, id, index, conditionType) {
+        var _this = this;
+        if (Array.isArray(condition))
+            return condition.map(function (_condition) {
+                return _this.executeCondition(_condition, id, index, conditionType);
+            });
+        var currentData;
+        if (conditionType === "options" || conditionType === "optionValidator") {
+            currentData = this.populateData(id, index, condition.dataMap);
+        }
+        else if (conditionType === "variables" ||
+            conditionType === "prefillers" ||
+            conditionType === "variableValidator") {
+            var dataId = this.references.relations.variables[id].parents[0];
+            currentData = this.populateData(dataId, index, condition.dataMap);
+        }
+        else if (conditionType === "sections" || conditionType === "documents") {
+            currentData = this.populateData(id, index, condition.dataMap, false);
+        }
+        return lplogic_1.default(condition.conditions, currentData);
+    };
+    return ConditionsRunner;
+}());
+exports.default = ConditionsRunner;

package/dist/libs/DocumentRender.d.ts

@@ -0,0 +1,15 @@
+import { Types } from "@legalplace/referencesparser";
+import ConditionsRunner from "./ConditionsRunner";
+import OVC_TYPE from "./ovc.type";
+import NumAuto from "./NumAuto";
+declare class DocumentRender {
+    references: Types.ReferencesType;
+    conditions: ConditionsRunner;
+    ovc: OVC_TYPE;
+    documents: Record<string, string[]>;
+    documentsNamesHash: Record<string, string>;
+    private NumAuto;
+    constructor(references: Types.ReferencesType, conditions: ConditionsRunner, ovc: OVC_TYPE, numauto: NumAuto);
+    renderDocument(documentName: string): string;
+}
+export default DocumentRender;

package/dist/libs/DocumentRender.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var SectionRender_1 = __importDefault(require("./SectionRender"));
+var DocumentRender = (function () {
+    function DocumentRender(references, conditions, ovc, numauto) {
+        this.documents = {};
+        this.documentsNamesHash = {};
+        this.references = references;
+        this.conditions = conditions;
+        this.ovc = ovc;
+        this.NumAuto = numauto;
+    }
+    DocumentRender.prototype.renderDocument = function (documentName) {
+        var _this = this;
+        var documentOutputs = [];
+        this.NumAuto.resetIndexes();
+        Object.keys(this.references.sections[documentName]).forEach(function (sectionId) {
+            documentOutputs.push.apply(documentOutputs, new SectionRender_1.default({
+                references: _this.references,
+                conditions: _this.conditions,
+                documentName: documentName,
+                ovc: _this.ovc,
+                currentSection: parseInt(sectionId, 10),
+                numauto: _this.NumAuto
+            }).getOutputs());
+        });
+        return documentOutputs.join("");
+    };
+    return DocumentRender;
+}());
+exports.default = DocumentRender;

package/dist/libs/NumAuto.d.ts

@@ -0,0 +1,8 @@
+declare class NumAuto {
+    indexesList: Record<string, any>;
+    tagsIndex: Record<string, number>;
+    getNum: (index: string, tag: string | null) => number;
+    getNumPre: (index: string) => number;
+    resetIndexes: () => void;
+}
+export default NumAuto;

package/dist/libs/NumAuto.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var NumAuto = (function () {
+    function NumAuto() {
+        var _this = this;
+        this.indexesList = {};
+        this.tagsIndex = {};
+        this.getNum = function (index, tag) {
+            if (!Object.prototype.hasOwnProperty.call(_this.indexesList, index)) {
+                if (Object.prototype.hasOwnProperty.call(_this.tagsIndex, index))
+                    return _this.tagsIndex[index];
+                _this.indexesList[index] = 0;
+            }
+            _this.indexesList[index] += 1;
+            if (typeof tag === "string")
+                _this.tagsIndex[tag] = _this.indexesList[index];
+            return _this.indexesList[index];
+        };
+        this.getNumPre = function (index) {
+            if (!Object.prototype.hasOwnProperty.call(_this.indexesList, index)) {
+                if (Object.prototype.hasOwnProperty.call(_this.tagsIndex, index))
+                    return _this.tagsIndex[index];
+            }
+            return _this.indexesList[index];
+        };
+        this.resetIndexes = function () {
+            _this.indexesList = {};
+        };
+    }
+    return NumAuto;
+}());
+exports.default = NumAuto;

package/dist/libs/OptionRender.d.ts

@@ -0,0 +1,25 @@
+import { Types } from "@legalplace/referencesparser";
+import ConditionsRunner from "./ConditionsRunner";
+import OVC_TYPE from "./ovc.type";
+import NumAuto from "./NumAuto";
+declare class OptionRender {
+    outputs: string[];
+    references: Types.ReferencesType;
+    index: number;
+    id: number;
+    conditions: ConditionsRunner;
+    ovc: OVC_TYPE;
+    private NumAuto;
+    constructor(options: {
+        references: Types.ReferencesType;
+        conditions: ConditionsRunner;
+        ovc: OVC_TYPE;
+        index: number;
+        id: number;
+        numauto: NumAuto;
+    });
+    getOutputs(): string[];
+    private renderOption;
+    private renderChildren;
+}
+export default OptionRender;

package/dist/libs/OptionRender.js

@@ -0,0 +1,73 @@
+"use strict";
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var OutputParser_1 = require("./OutputParser");
+var OptionRender = (function () {
+    function OptionRender(options) {
+        this.outputs = [];
+        this.references = options.references;
+        this.conditions = options.conditions;
+        this.index = options.index;
+        this.id = options.id;
+        this.ovc = options.ovc;
+        this.NumAuto = options.numauto;
+        this.renderOption();
+    }
+    OptionRender.prototype.getOutputs = function () {
+        return this.outputs;
+    };
+    OptionRender.prototype.renderOption = function () {
+        var _this = this;
+        var option = this.references.options[this.id];
+        var conditionObject = this.references.conditions.options[this.id];
+        var condition = conditionObject === undefined
+            ? true
+            : this.conditions.executeCondition(conditionObject, this.id, this.index, "options");
+        if (condition === true) {
+            if (typeof option.meta.output === "string" &&
+                option.meta.output.trim().length > 0) {
+                var outputReference = this.references.outputs[this.id];
+                var autonums = [];
+                if (condition !== false) {
+                    autonums = outputReference.autonums.map(function (currentAn) {
+                        var fn = currentAn[0] === "numauto-pre"
+                            ? _this.NumAuto.getNumPre
+                            : _this.NumAuto.getNum;
+                        return [
+                            currentAn[0],
+                            currentAn[1],
+                            fn(currentAn[1], currentAn[2]),
+                            currentAn[2]
+                        ];
+                    });
+                }
+                var variables = OutputParser_1.getRelatedVariablesValues(this.id, this.index, outputReference.variables, this.ovc, this.references);
+                var output = OutputParser_1.parseOutputWithVariables(option.meta.output, variables, autonums);
+                this.outputs.push(output);
+            }
+            this.renderChildren();
+        }
+    };
+    OptionRender.prototype.renderChildren = function () {
+        var _this = this;
+        var option = this.references.options[this.id];
+        option.options.forEach(function (optionId) {
+            _this.outputs = __spreadArrays(_this.outputs, new OptionRender({
+                references: _this.references,
+                id: optionId,
+                ovc: _this.ovc,
+                index: _this.index,
+                conditions: _this.conditions,
+                numauto: _this.NumAuto
+            }).getOutputs());
+        });
+    };
+    return OptionRender;
+}());
+exports.default = OptionRender;

package/dist/libs/OutputParser.d.ts

@@ -0,0 +1,9 @@
+import { Types } from "@legalplace/referencesparser";
+import OVC_TYPE from "./ovc.type";
+declare type relVarsValsT = Record<string, string | number>;
+declare type getRelatedVarsT = (optionId: number, index: number, variables: number[], ovc: OVC_TYPE, references: Types.ReferencesType) => relVarsValsT;
+export declare const getRelatedVariablesValues: getRelatedVarsT;
+declare type autonumsType = [string, string, number, string | null][];
+declare type parseOutputT = (output: string, variables: relVarsValsT, autonums: autonumsType) => string;
+export declare const parseOutputWithVariables: parseOutputT;
+export {};

package/dist/libs/OutputParser.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelatedVariablesValues = function (optionId, index, variables, ovc, references) {
+    var variablesValues = {};
+    variables.forEach(function (currentVariableId) {
+        var value = ovc.variables[currentVariableId] || [""];
+        var variableParents = references.relations.variables[currentVariableId].parents;
+        if (variableParents === undefined)
+            throw new Error("Variable " + currentVariableId + " parents object does not exist");
+        var rootVariableParentId = variableParents[variableParents.length - 1];
+        var rootVariableParentRelations = references.relations.options[rootVariableParentId];
+        if (rootVariableParentRelations === undefined)
+            throw new Error("Option " + rootVariableParentId + " does not exist");
+        if (typeof variableParents === "undefined")
+            return;
+        if (rootVariableParentRelations.children.options.includes(optionId) ||
+            rootVariableParentRelations.dependants.includes(optionId) ||
+            optionId === rootVariableParentId)
+            value = [value[index]];
+        var cleanValues = value.map(function (currentValue) {
+            if (typeof currentValue === "number")
+                return currentValue.toString();
+            if (typeof currentValue === "string")
+                return currentValue;
+            return "";
+        });
+        variablesValues[currentVariableId] =
+            cleanValues.length === 1 ? cleanValues[0] : cleanValues.join(", ");
+    });
+    return variablesValues;
+};
+exports.parseOutputWithVariables = function (output, variables, autonums) {
+    var parsedOutput = "" + output;
+    Object.keys(variables).forEach(function (variableId) {
+        var value = variables[variableId].toString();
+        if (value.trim().length === 0) {
+            value = new Array(16).join("_");
+        }
+        parsedOutput = parsedOutput.replace(new RegExp("\\[var:" + variableId + "\\]", "g"), value);
+    });
+    parsedOutput = parsedOutput.replace("[[PAGE_BREAK]]", '<p class="pagebreak"><!-- pagebreak --></p>');
+    autonums.forEach(function (currentAn) {
+        if (currentAn[3] === null)
+            parsedOutput = parsedOutput.replace("[" + currentAn[0] + ":" + currentAn[1] + "]", "<span class=\"" + currentAn[0] + "\">" + currentAn[2] + "</span>");
+        else
+            parsedOutput = parsedOutput.replace("[" + currentAn[0] + ":" + currentAn[1] + "](" + currentAn[3] + ")", "<span class=\"" + currentAn[0] + "\">" + currentAn[2] + "</span>");
+    });
+    return parsedOutput;
+};

package/dist/libs/Prerender.d.ts

@@ -0,0 +1,22 @@
+import { ModelV3 } from "@legalplace/models-v3-types";
+import OVC_TYPE from "./ovc.type";
+declare class Prerender {
+    private model;
+    private references;
+    private ovc;
+    private conditions;
+    private documentRender;
+    private NumAuto;
+    private documentsIndex;
+    private renderedDocuments;
+    constructor(model: ModelV3, ovc: OVC_TYPE);
+    getDocumentsIndex(): Record<string, {
+        name: string;
+        pdf: boolean;
+        docx: boolean;
+    }>;
+    private generateDocumentNamesHash;
+    private generateAllDocuments;
+    getDocument(documentNameHash: string): string;
+}
+export default Prerender;

package/dist/libs/Prerender.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var referencesparser_1 = require("@legalplace/referencesparser");
+var crypto_1 = __importDefault(require("crypto"));
+var DocumentRender_1 = __importDefault(require("./DocumentRender"));
+var ConditionsRunner_1 = __importDefault(require("./ConditionsRunner"));
+var NumAuto_1 = __importDefault(require("./NumAuto"));
+var Prerender = (function () {
+    function Prerender(model, ovc) {
+        this.documentsIndex = {};
+        this.renderedDocuments = {};
+        this.model = model;
+        this.ovc = ovc;
+        this.NumAuto = new NumAuto_1.default();
+        this.references = new referencesparser_1.ReferencesParser(model).getReferences();
+        this.conditions = new ConditionsRunner_1.default(this.references, this.ovc);
+        this.documentRender = new DocumentRender_1.default(this.references, this.conditions, this.ovc, this.NumAuto);
+        this.generateDocumentNamesHash();
+        this.generateAllDocuments();
+    }
+    Prerender.prototype.getDocumentsIndex = function () {
+        return this.documentsIndex;
+    };
+    Prerender.prototype.generateDocumentNamesHash = function () {
+        var _this = this;
+        Object.keys(this.model.documents).forEach(function (documentName) {
+            var conditionObject = _this.references.conditions.documents[documentName];
+            var condition = conditionObject === undefined
+                ? true
+                : _this.conditions.executeCondition(conditionObject, 0, 0, "documents");
+            if (condition === true) {
+                var hash = crypto_1.default
+                    .createHash("sha1")
+                    .update(documentName)
+                    .digest("hex");
+                _this.documentsIndex[hash] = {
+                    name: documentName,
+                    pdf: true,
+                    docx: true
+                };
+            }
+        });
+    };
+    Prerender.prototype.generateAllDocuments = function () {
+        var _this = this;
+        Object.keys(this.documentsIndex).forEach(function (documentNameHash) {
+            _this.renderedDocuments[documentNameHash] = _this.documentRender.renderDocument(_this.documentsIndex[documentNameHash].name);
+        });
+    };
+    Prerender.prototype.getDocument = function (documentNameHash) {
+        return this.renderedDocuments[documentNameHash];
+    };
+    return Prerender;
+}());
+exports.default = Prerender;