touchstudy-core 0.1.38 → 0.1.39

package/dist/index.js

@@ -154,11 +154,165 @@ var AuthenticationMessage;
 })(exports.Role || (exports.Role = {}));
 
 // A type of promise-like that resolves synchronously and supports only one observer
+const _Pact = /*#__PURE__*/(function() {
+	function _Pact() {}
+	_Pact.prototype.then = function(onFulfilled, onRejected) {
+		const result = new _Pact();
+		const state = this.s;
+		if (state) {
+			const callback = state & 1 ? onFulfilled : onRejected;
+			if (callback) {
+				try {
+					_settle(result, 1, callback(this.v));
+				} catch (e) {
+					_settle(result, 2, e);
+				}
+				return result;
+			} else {
+				return this;
+			}
+		}
+		this.o = function(_this) {
+			try {
+				const value = _this.v;
+				if (_this.s & 1) {
+					_settle(result, 1, onFulfilled ? onFulfilled(value) : value);
+				} else if (onRejected) {
+					_settle(result, 1, onRejected(value));
+				} else {
+					_settle(result, 2, value);
+				}
+			} catch (e) {
+				_settle(result, 2, e);
+			}
+		};
+		return result;
+	};
+	return _Pact;
+})();
+
+// Settles a pact synchronously
+function _settle(pact, state, value) {
+	if (!pact.s) {
+		if (value instanceof _Pact) {
+			if (value.s) {
+				if (state & 1) {
+					state = value.s;
+				}
+				value = value.v;
+			} else {
+				value.o = _settle.bind(null, pact, state);
+				return;
+			}
+		}
+		if (value && value.then) {
+			value.then(_settle.bind(null, pact, state), _settle.bind(null, pact, 2));
+			return;
+		}
+		pact.s = state;
+		pact.v = value;
+		const observer = pact.o;
+		if (observer) {
+			observer(pact);
+		}
+	}
+}
+
+function _isSettledPact(thenable) {
+	return thenable instanceof _Pact && thenable.s & 1;
+}
 
 const _iteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator"))) : "@@iterator";
 
 const _asyncIteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.asyncIterator || (Symbol.asyncIterator = Symbol("Symbol.asyncIterator"))) : "@@asyncIterator";
 
+// Asynchronously implement a generic for loop
+function _for(test, update, body) {
+	var stage;
+	for (;;) {
+		var shouldContinue = test();
+		if (_isSettledPact(shouldContinue)) {
+			shouldContinue = shouldContinue.v;
+		}
+		if (!shouldContinue) {
+			return result;
+		}
+		if (shouldContinue.then) {
+			stage = 0;
+			break;
+		}
+		var result = body();
+		if (result && result.then) {
+			if (_isSettledPact(result)) {
+				result = result.s;
+			} else {
+				stage = 1;
+				break;
+			}
+		}
+		if (update) {
+			var updateValue = update();
+			if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
+				stage = 2;
+				break;
+			}
+		}
+	}
+	var pact = new _Pact();
+	var reject = _settle.bind(null, pact, 2);
+	(stage === 0 ? shouldContinue.then(_resumeAfterTest) : stage === 1 ? result.then(_resumeAfterBody) : updateValue.then(_resumeAfterUpdate)).then(void 0, reject);
+	return pact;
+	function _resumeAfterBody(value) {
+		result = value;
+		do {
+			if (update) {
+				updateValue = update();
+				if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
+					updateValue.then(_resumeAfterUpdate).then(void 0, reject);
+					return;
+				}
+			}
+			shouldContinue = test();
+			if (!shouldContinue || (_isSettledPact(shouldContinue) && !shouldContinue.v)) {
+				_settle(pact, 1, result);
+				return;
+			}
+			if (shouldContinue.then) {
+				shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+				return;
+			}
+			result = body();
+			if (_isSettledPact(result)) {
+				result = result.v;
+			}
+		} while (!result || !result.then);
+		result.then(_resumeAfterBody).then(void 0, reject);
+	}
+	function _resumeAfterTest(shouldContinue) {
+		if (shouldContinue) {
+			result = body();
+			if (result && result.then) {
+				result.then(_resumeAfterBody).then(void 0, reject);
+			} else {
+				_resumeAfterBody(result);
+			}
+		} else {
+			_settle(pact, 1, result);
+		}
+	}
+	function _resumeAfterUpdate() {
+		if (shouldContinue = test()) {
+			if (shouldContinue.then) {
+				shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+			} else {
+				_resumeAfterTest(shouldContinue);
+			}
+		} else {
+			_settle(pact, 1, result);
+		}
+	}
+}
+
 // Asynchronously call a function and send errors to recovery continuation
 function _catch(body, recover) {
 	try {
@@ -9235,19 +9389,53 @@ var useExamResult = function useExamResult(searchParam, navigate, examSessionId,
       var canvas = document.querySelector("#canvas");
       var headerCanvas = document.querySelector("#header-canvas");
       if (!canvas || !headerCanvas) return Promise.resolve();
-      var doc = new jspdf.jsPDF();
-      var imgWidth = 208;
-      var bodyWidth = 202;
+      var doc = new jspdf.jsPDF({
+        orientation: "p",
+        unit: "px",
+        format: "a4"
+      });
+      var WIDTH_PAPER = doc.internal.pageSize.width;
+      var HEIGHT_PAPER = doc.internal.pageSize.height;
+      var line = 0;
+      var imgWidth = WIDTH_PAPER;
+      var chartWidth = WIDTH_PAPER - 20;
       return Promise.resolve(html2canvas(headerCanvas)).then(function (header) {
+        function _temp11() {
+          doc.save("download.pdf");
+        }
         var imgHeaderHeight = header.height * imgWidth / header.width;
         var imgHeaderData = header.toDataURL('image/png');
         doc.addImage(imgHeaderData, 'PNG', 0, 0, imgWidth, imgHeaderHeight);
-        return Promise.resolve(html2canvas(canvas)).then(function (body) {
-          var imgBodyHeight = body.height * bodyWidth / body.width;
-          var imgBodyData = body.toDataURL('image/png');
-          doc.addImage(imgBodyData, 'PNG', 4, imgHeaderHeight, bodyWidth, imgBodyHeight);
-          doc.save("download.pdf");
-        });
+        line += imgHeaderHeight;
+        if (line > HEIGHT_PAPER) {
+          doc.addPage();
+          line = 20;
+        }
+        var _temp10 = function () {
+          if (canvas && canvas.childElementCount > 0) {
+            var _index = 0;
+            var _temp9 = _for(function () {
+              return _index < canvas.childElementCount;
+            }, function () {
+              return _index++;
+            }, function () {
+              var chart = canvas.children.item(_index);
+              return Promise.resolve(html2canvas(chart)).then(function (chartCanvas) {
+                var imgBodyHeight = chartCanvas.height * chartWidth / chartCanvas.width;
+                var imgBodyData = chartCanvas.toDataURL('image/png');
+                line += 10;
+                if (line + imgBodyHeight > HEIGHT_PAPER) {
+                  doc.addPage();
+                  line = 20;
+                }
+                doc.addImage(imgBodyData, 'PNG', 10, line, chartWidth, imgBodyHeight);
+                line += imgBodyHeight;
+              });
+            });
+            if (_temp9 && _temp9.then) return _temp9.then(function () {});
+          }
+        }();
+        return _temp10 && _temp10.then ? _temp10.then(_temp11) : _temp11(_temp10);
       });
     } catch (e) {
       return Promise.reject(e);