tina4ruby 0.5.2 → 3.2.1

data/lib/tina4/public/js/frond.min.js

@@ -0,0 +1,420 @@
+(function (global, factory) {
+if (typeof define === 'function' && define.amd) {
+define([], factory);
+} else if (typeof module !== 'undefined' && module.exports){
+module.exports = factory();
+} else {
+global.ReconnectingWebSocket = factory();
+}
+})(this, function () {
+if (!('WebSocket' in window)) {
+return;
+}
+function ReconnectingWebSocket(url, protocols, options) {
+var settings = {
+debug: false,
+automaticOpen: true,
+reconnectInterval: 1000,
+maxReconnectInterval: 30000,
+reconnectDecay: 1.5,
+timeoutInterval: 2000,
+maxReconnectAttempts: null,
+binaryType: 'blob'
+}
+if (!options) { options = {}; }
+for (var key in settings) {
+if (typeof options[key] !== 'undefined') {
+this[key] = options[key];
+} else {
+this[key] = settings[key];
+}
+}
+this.url = url;
+this.reconnectAttempts = 0;
+this.readyState = WebSocket.CONNECTING;
+this.protocol = null;
+var self = this;
+var ws;
+var forcedClose = false;
+var timedOut = false;
+var eventTarget = document.createElement('div');
+eventTarget.addEventListener('open',       function(event) { self.onopen(event); });
+eventTarget.addEventListener('close',      function(event) { self.onclose(event); });
+eventTarget.addEventListener('connecting', function(event) { self.onconnecting(event); });
+eventTarget.addEventListener('message',    function(event) { self.onmessage(event); });
+eventTarget.addEventListener('error',      function(event) { self.onerror(event); });
+this.addEventListener = eventTarget.addEventListener.bind(eventTarget);
+this.removeEventListener = eventTarget.removeEventListener.bind(eventTarget);
+this.dispatchEvent = eventTarget.dispatchEvent.bind(eventTarget);
+function generateEvent(s, args) {
+var evt = document.createEvent("CustomEvent");
+evt.initCustomEvent(s, false, false, args);
+return evt;
+};
+this.open = function (reconnectAttempt) {
+ws = new WebSocket(self.url, protocols || []);
+ws.binaryType = this.binaryType;
+if (reconnectAttempt) {
+if (this.maxReconnectAttempts && this.reconnectAttempts > this.maxReconnectAttempts) {
+return;
+}
+} else {
+eventTarget.dispatchEvent(generateEvent('connecting'));
+this.reconnectAttempts = 0;
+}
+if (self.debug || ReconnectingWebSocket.debugAll) {
+console.debug('ReconnectingWebSocket', 'attempt-connect', self.url);
+}
+var localWs = ws;
+var timeout = setTimeout(function() {
+if (self.debug || ReconnectingWebSocket.debugAll) {
+console.debug('ReconnectingWebSocket', 'connection-timeout', self.url);
+}
+timedOut = true;
+localWs.close();
+timedOut = false;
+}, self.timeoutInterval);
+ws.onopen = function(event) {
+clearTimeout(timeout);
+if (self.debug || ReconnectingWebSocket.debugAll) {
+console.debug('ReconnectingWebSocket', 'onopen', self.url);
+}
+self.protocol = ws.protocol;
+self.readyState = WebSocket.OPEN;
+self.reconnectAttempts = 0;
+var e = generateEvent('open');
+e.isReconnect = reconnectAttempt;
+reconnectAttempt = false;
+eventTarget.dispatchEvent(e);
+};
+ws.onclose = function(event) {
+clearTimeout(timeout);
+ws = null;
+if (forcedClose) {
+self.readyState = WebSocket.CLOSED;
+eventTarget.dispatchEvent(generateEvent('close'));
+} else {
+self.readyState = WebSocket.CONNECTING;
+var e = generateEvent('connecting');
+e.code = event.code;
+e.reason = event.reason;
+e.wasClean = event.wasClean;
+eventTarget.dispatchEvent(e);
+if (!reconnectAttempt && !timedOut) {
+if (self.debug || ReconnectingWebSocket.debugAll) {
+console.debug('ReconnectingWebSocket', 'onclose', self.url);
+}
+eventTarget.dispatchEvent(generateEvent('close'));
+}
+var timeout = self.reconnectInterval * Math.pow(self.reconnectDecay, self.reconnectAttempts);
+setTimeout(function() {
+self.reconnectAttempts++;
+self.open(true);
+}, timeout > self.maxReconnectInterval ? self.maxReconnectInterval : timeout);
+}
+};
+ws.onmessage = function(event) {
+if (self.debug || ReconnectingWebSocket.debugAll) {
+console.debug('ReconnectingWebSocket', 'onmessage', self.url, event.data);
+}
+var e = generateEvent('message');
+e.data = event.data;
+eventTarget.dispatchEvent(e);
+};
+ws.onerror = function(event) {
+if (self.debug || ReconnectingWebSocket.debugAll) {
+console.debug('ReconnectingWebSocket', 'onerror', self.url, event);
+}
+eventTarget.dispatchEvent(generateEvent('error'));
+};
+}
+if (this.automaticOpen == true) {
+this.open(false);
+}
+this.send = function(data) {
+if (ws) {
+if (self.debug || ReconnectingWebSocket.debugAll) {
+console.debug('ReconnectingWebSocket', 'send', self.url, data);
+}
+return ws.send(data);
+} else {
+throw 'INVALID_STATE_ERR : Pausing to reconnect websocket';
+}
+};
+this.close = function(code, reason) {
+if (typeof code == 'undefined') {
+code = 1000;
+}
+forcedClose = true;
+if (ws) {
+ws.close(code, reason);
+}
+};
+this.refresh = function() {
+if (ws) {
+ws.close();
+}
+};
+}
+ReconnectingWebSocket.prototype.onopen = function(event) {};
+ReconnectingWebSocket.prototype.onclose = function(event) {};
+ReconnectingWebSocket.prototype.onconnecting = function(event) {};
+ReconnectingWebSocket.prototype.onmessage = function(event) {};
+ReconnectingWebSocket.prototype.onerror = function(event) {};
+ReconnectingWebSocket.debugAll = false;
+ReconnectingWebSocket.CONNECTING = WebSocket.CONNECTING;
+ReconnectingWebSocket.OPEN = WebSocket.OPEN;
+ReconnectingWebSocket.CLOSING = WebSocket.CLOSING;
+ReconnectingWebSocket.CLOSED = WebSocket.CLOSED;
+return ReconnectingWebSocket;
+});
+var formToken = null;
+function sendRequest(url, request, method, callback) {
+if (url === undefined)       url = "";
+if (request === undefined)   request = null;
+if (method === undefined)    method = 'GET';
+const xhr = new XMLHttpRequest();
+xhr.open(method, url, true);
+if (formToken !== null) {
+xhr.setRequestHeader('Authorization', 'Bearer ' + formToken);
+}
+let isFormData = request instanceof FormData;
+if (method.toUpperCase() === 'POST' || method.toUpperCase() === 'PUT' || method.toUpperCase() === 'PATCH') {
+if (isFormData) {
+} else if (typeof request === 'object' && request !== null) {
+request = JSON.stringify(request);
+xhr.setRequestHeader('Content-Type', 'application/json; charset=UTF-8');
+} else if (typeof request === 'string') {
+xhr.setRequestHeader('Content-Type', 'text/plain; charset=UTF-8');
+}
+}
+xhr.onload = function () {
+let content = xhr.response;
+const freshToken = xhr.getResponseHeader('FreshToken');
+if (freshToken && freshToken !== '') {
+formToken = freshToken;
+}
+try {
+content = JSON.parse(content);
+} catch (e) {
+}
+if (typeof callback === 'function') {
+callback(content, xhr.status, xhr);
+}
+};
+xhr.onerror = function () {
+if (typeof callback === 'function') {
+callback(null, xhr.status, xhr);
+}
+};
+xhr.send(request);
+}
+function getFormData(formId) {
+let data = new FormData();
+let elements = document.querySelectorAll("#" + formId + " select, #" + formId + " input, #" + formId + " textarea");
+for (let ie = 0; ie < elements.length; ie++ )
+{
+let element = elements[ie];
+if (element.name === 'formToken' && formToken !== null) {
+element.value = formToken;
+}
+if (element.name) {
+if (element.type === 'file') {
+for (let i = 0; i < element.files.length; i++) {
+let fileData = element.files[i];
+let elementName = element.name;
+if (fileData !== undefined) {
+if (element.files.length > 1 && !elementName.includes('[')) {
+elementName = elementName + '[]';
+}
+data.append(elementName, fileData, fileData.name);
+}
+}
+} else if (element.type === 'checkbox' || element.type === 'radio') {
+if (element.checked) {
+data.append(element.name, element.value)
+} else {
+if (element.type !== 'radio') {
+data.append(element.name, "0")
+}
+}
+} else {
+if (element.value === '') {
+element.value = null;
+}
+data.append(element.name, element.value);
+}
+}
+}
+return data;
+}
+function handleHtmlData(data, targetElement) {
+if (data === "") return '';
+const parser = new DOMParser();
+const htmlData = parser.parseFromString(data.includes !== undefined && data.includes('<html>') ? data : '<body>'+data+'</body></html>', 'text/html');
+const body = htmlData.querySelector('body');
+const scripts = body.querySelectorAll('script');
+body.querySelectorAll('script').forEach(script => script.remove());
+if (targetElement !== null) {
+if (body.children.length > 0) {
+document.getElementById(targetElement).replaceChildren(...body.children);
+} else {
+document.getElementById(targetElement).replaceChildren(body.innerHTML);
+}
+if (scripts) {
+scripts.forEach(script => {
+const newScript = document.createElement("script");
+newScript.type = 'text/javascript';
+newScript.async = true;
+newScript.textContent = script.innerText;
+document.getElementById(targetElement).append(newScript);
+});
+}
+} else {
+if (scripts) {
+scripts.forEach(script => {
+const newScript = document.createElement("script");
+newScript.type = 'text/javascript';
+newScript.async = true;
+newScript.textContent = script.innerText;
+document.body.append(newScript);
+console.log(newScript);
+});
+}
+return body.innerHTML;
+}
+return '';
+}
+function loadPage(loadURL, targetElement, callback = null) {
+if (targetElement === undefined) targetElement = 'content';
+sendRequest(loadURL, null, "GET", function(data) {
+let processedHTML = '';
+if (document.getElementById(targetElement) !== null) {
+processedHTML = handleHtmlData(data, targetElement);
+} else {
+if (callback) {
+callback(data);
+} else {
+console.log('TINA4 - define targetElement or callback for loadPage', data);
+}
+return;
+}
+if (callback) {
+callback(processedHTML, data);
+}
+});
+}
+function showForm(action, loadURL, targetElement, callback = null) {
+if (targetElement === undefined) targetElement = 'form';
+if (action === 'create') action = 'GET';
+if (action === 'edit') action = 'GET';
+if (action === 'delete') action = 'DELETE';
+sendRequest(loadURL, null, action, function(data) {
+let processedHTML = '';
+if (data.message !== undefined) {
+processedHTML = handleHtmlData ((data.message), targetElement);
+} else {
+if (document.getElementById(targetElement) !== null) {
+processedHTML = handleHtmlData (data, targetElement);
+} else {
+if (callback) {
+callback(data);
+} else {
+console.log('TINA4 - define targetElement or callback for showForm', data);
+}
+return;
+}
+}
+if (callback) {
+callback(processedHTML);
+}
+});
+}
+function postUrl(url, data, targetElement, callback= null) {
+sendRequest(url, data, 'POST', function(data) {
+let processedHTML = '';
+if (data.message !== undefined) {
+processedHTML = handleHtmlData ((data.message), targetElement);
+} else {
+if (document.getElementById(targetElement) !== null) {
+processedHTML =  handleHtmlData (data, targetElement);
+} else {
+if (callback) {
+callback(data);
+} else {
+console.log('TINA4 - define targetElement or callback for postUrl', data);
+}
+return;
+}
+}
+if (callback) {
+callback(processedHTML,data)
+}
+});
+}
+function saveForm(formId, targetURL, targetElement, callback = null) {
+if (targetElement === undefined) targetElement = 'message';
+let data = getFormData(formId);
+postUrl(targetURL, data, targetElement, callback);
+}
+function postForm(formId, targetURL, targetElement, callback = null){
+saveForm(formId, targetURL, targetElement, callback)
+}
+function submitForm(formId, targetURL, targetElement, callback = null){
+saveForm(formId, targetURL, targetElement, callback)
+}
+function showMessage(message) {
+document.getElementById('message').innerHTML = '<div class="alert alert-info alert-dismissible fade show"><strong>Info</strong> ' + message + '<button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button></div>';
+}
+function setCookie(name, value, days) {
+let expires = "";
+if (days) {
+let date = new Date();
+date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+expires = "; expires=" + date.toUTCString();
+}
+document.cookie = name + "=" + (value || "") + expires + "; path=/";
+}
+function getCookie(name) {
+let nameEQ = name + "=";
+let ca = document.cookie.split(';');
+for (let i = 0; i < ca.length; i++) {
+var c = ca[i];
+while (c.charAt(0) == ' ') c = c.substring(1, c.length);
+if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length, c.length);
+}
+return null;
+}
+const popupCenter = ({url, title, w, h}) => {
+const dualScreenLeft = window.screenLeft !== undefined ? window.screenLeft : window.screenX;
+const dualScreenTop = window.screenTop !== undefined ? window.screenTop : window.screenY;
+const width = window.innerWidth ? window.innerWidth : document.documentElement.clientWidth ? document.documentElement.clientWidth : screen.width;
+const height = window.innerHeight ? window.innerHeight : document.documentElement.clientHeight ? document.documentElement.clientHeight : screen.height;
+const systemZoom = width / window.screen.availWidth;
+const left = (width - w) / 2 / systemZoom + dualScreenLeft
+const top = (height - h) / 2 / systemZoom + dualScreenTop
+const newWindow = window.open(url, title,
+`
+directories=no,toolbar=no,location=no,status=no,menubar=no,scrollbars=no,resizable=no,
+width=${w / systemZoom},
+height=${h / systemZoom},
+top=${top},
+left=${left}
+`
+)
+if (window.focus) newWindow.focus();
+return newWindow;
+}
+function openReport(pdfReportPath){
+if (pdfReportPath.indexOf("No data available") < 0){
+open(pdfReportPath, "content", "target=_blank, toolbar=no, scrollbars=yes, resizable=yes, width=800, height=600, top=0, left=0");
+}
+else {
+window.alert("Sorry , unable to print a report according to your selection!");
+}
+}
+function getRoute(loadURL, callback) {
+sendRequest(loadURL, null, 'GET', function(data) {
+callback(handleHtmlData (data, null));
+});
+}