vesta-web 1.1.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

vesta/emptyProject/static/framework/global.mjs

@@ -0,0 +1,11 @@
+let global = {
+    "state":{
+    },
+    "i18n":{
+    },
+    "settings":{
+    },
+    "user":{
+    },
+}
+export default global

vesta/emptyProject/static/framework/navigation.mjs

@@ -0,0 +1,295 @@
+import global from "./global.mjs";
+import {xhr} from "./templating.mjs";
+
+
+/**
+ * Opens a menu by its DOM id. If the menu element exists, it is displayed. Otherwise, loads the menu template asynchronously.
+ * @param {string} id - The DOM id of the menu to open.
+ * @param {boolean} [async=true] - Whether to load the template asynchronously if not found.
+ */
+function openMenu(id, async=true){
+    const menu = document.getElementById(id)
+    if (menu){
+        menu.style.display = "flex"
+    }else{
+        loadTemplate(id.concat(".html"), undefined, id, async)
+    }
+}
+window.openMenu = openMenu
+
+/**
+ * Toggles the display of a menu by its DOM id. If the menu exists, toggles its visibility. Otherwise, loads the menu template.
+ * @param {string} id - The DOM id of the menu to toggle.
+ * @param {boolean} [async=true] - Whether to load the template asynchronously if not found.
+ * @param {HTMLElement} [target=undefined] - Optional target HTML element for template loading.
+ */
+function toggleMenu(id, async=true,target=undefined){
+    const menu = document.getElementById(id)
+    if (menu){
+        if (menu.style.display === "flex"){
+            menu.style.display = "none"
+            return
+        }
+        menu.style.display = "flex"
+    }else{
+        loadTemplate(id.concat(".html"), target, id, async)
+    }
+}
+window.toggleMenu = toggleMenu
+
+/**
+ * Navigates to a new view or section by loading a template and updating selection state.
+ *
+ * @param {string} id - The id of the element to inject the template into.
+ * @param {string} target - The base name of the template to load (without .html).
+ * @param {Object} [selected=undefined] - Optional selection context {category | event | id} allowing to add/remove the "selected" class.
+ * @param {boolean} [async=true] - Whether to load the template asynchronously.
+ * @param {Function} [postInsert=undefined] - Optional callback to run after template insertion.
+ *
+ */
+export function goTo(id, target, selected=undefined, async=true, postInsert=undefined){
+    if (postInsert){
+        loadTemplate(target.concat(".html"), id, undefined, false)
+        postInsert()
+    }else{
+        loadTemplate(target.concat(".html"), id, undefined, async)
+    }
+    
+    if(selected){
+        let targetElt;
+        if(global.state[selected.category]){
+            global.state[selected.category].classList.remove("selected")
+        }else if(selected.event){
+            selected.event.currentTarget.parentElement.querySelector('.selected').classList.remove("selected")
+        }else if(selected.id){
+            targetElt = document.getElementById(selected.id)
+            targetElt.parentElement.querySelector('.selected').classList.remove("selected")
+        }
+
+        if(selected.event){
+            global.state[selected.category] = selected.event.currentTarget
+        }else if(selected.id){
+            global.state[selected.category] = targetElt
+        }
+        global.state[selected.category].classList.add("selected")
+    }
+}
+window.goTo = goTo
+
+
+let openingFM = false;
+
+
+/**
+ * Toggles the visibility of a floating menu (FM) by its DOM id.
+ * If another FM is open, it will be hidden and the new one will be shown.
+ *
+ * @param {string} id - The DOM id of the floating menu to toggle.
+ */
+function toggleFM(id){
+    const FM = document.getElementById(id)
+    if(FM !== global.state.activeFM){
+        openingFM = true
+        if(global.state.activeFM){
+            global.state.activeFM.classList.toggle("visible")
+        }
+        global.state.activeFM = FM
+    }
+}
+window.toggleFM = toggleFM
+
+/**
+ * Closes the currently active floating menu (FM) if one is open.
+ */
+export function closeFM(){
+    if(global.state.activeFM){
+        global.state.activeFM.classList.toggle("visible")
+        global.state.activeFM = undefined
+    }
+}
+
+/**
+ * Toggles the display of a modal window at the mouse event position.
+ * If another modal is open, it will be hidden and the new one will be shown at the event's coordinates.
+ *
+ * @param {string} id - The DOM id of the modal to toggle.
+ * @param {Event} event - The event triggering the modal (used for positioning).
+ */
+function toggleModale(id, event){
+    const FM = document.getElementById(id)
+    if(FM !== global.state.activeFM){
+        openingFM = true
+        global.state.modaltarget = event.currentTarget
+        if(global.state.activeFM){
+            global.state.activeFM.classList.toggle("visible")
+        }
+        console.log(event.currentTarget,global.state.modaltarget)
+        FM.style.top = event.clientY.toString().concat("px")
+        FM.style.left = event.clientX.toString().concat("px")
+        global.state.activeFM = FM
+        if (event.type === "contextmenu"){
+            event.preventDefault()
+            global.state.activeFM.classList.add("visible")
+        }
+    }
+}
+window.toggleModale = toggleModale
+
+/**
+ * Toggles the closed/open state of a group element (e.g., collapsible section).
+ */
+function toggleGroup(){
+    event.currentTarget.classList.toggle("closed")
+}
+window.toggleGroup = toggleGroup
+
+/**
+ * Navigates to a specific step in a multi-step menu by translating the menu horizontally.
+ *
+ * @param {number} step - The step index to navigate to.
+ * @param {string} stepsID - The DOM id of the steps container.
+ */
+function gotoStep(step,stepsID){
+    const menu = document.getElementById(stepsID)
+    menu.style.transform=`translateX(${-100*step/menu.childElementCount}%)`
+}
+window.gotoStep = gotoStep
+
+/**
+ * Removes the 'selected' class from all elements with class 'selected' inside the given container.
+ * Used for resetting selection state in multi-step menus.
+ *
+ * @param {string} id - The DOM id of the container to reset selection in.
+ */
+function resetSelected(id){
+    const selected = document.getElementById(id).querySelectorAll(".selected")
+    for(let el of selected){
+        el.classList.remove("selected")
+    }
+}
+
+/**
+ * Closes a menu by hiding it and resetting its state. Can target a specific element or use the event target.
+ *
+ * @param {string|undefined} cible - CSS selector of the element to close, or undefined to use event target.
+ * @param {string} [id='createServerSteps'] - The DOM id of the steps container to reset.
+ *
+ */
+function closeMenu(cible = undefined,id='createServerSteps'){
+    if (global.state.disableClose){
+        return
+    }
+
+    if(!cible){
+        if(event.target !== event.currentTarget){
+            return
+        }
+        event.target.style.display = "none";
+    }else{
+        const cibleEl= document.querySelector(cible)
+        cibleEl.style.display = "none";
+    }
+    gotoStep(0,id)
+    resetSelected(id)
+}
+window.closeMenu = closeMenu
+
+/**
+ * Saves the current cursor position in a text input or textarea to global state.
+ * Used to paste emojis in a textarea from an emoji-keyboard.
+ *
+ * @param {Event} event - The input event containing the cursor position.
+ */
+function saveCursorPosition(event){
+    global.state.previousCursor={start:event.srcElement.selectionStart, end:event.srcElement.selectionEnd}
+}
+window.saveCursorPosition = saveCursorPosition
+
+function isMobileDevice() {
+    return /Mobi|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+}
+
+export function initNavigation(){
+    window.global = global
+    global.state.dom = document.querySelector("body")
+
+    const { hostname, port } = window.location;
+    global.state.location = { host:hostname, port:port, short:port ? hostname + ":" + port : hostname }
+
+    global.state.isMobile = isMobileDevice()
+    if (global.state.isMobile) {
+        global.state.dom.classList.add("mobile")
+
+        const onload = function(){
+            console.log(this.responseText)
+        }
+        xhr("/static/mobileUiManifest.mjs", onload)
+    }
+
+    document.addEventListener('click', function (event) {
+        if (global.state.activeFM && !global.state.activeFM.contains(event.target)) {
+            global.state.activeFM.classList.toggle("visible")
+            if (!openingFM){
+                global.state.activeFM = undefined
+            }else{
+                openingFM=false
+            }
+        }
+    }, false);
+
+    if (global.state.socket){
+        window.addEventListener('unload', () => {
+            if (global.state?.socket.readyState !== WebSocket.CLOSED) {
+                const message = {"type" : 'unregister', "clientID":global.state.clientID}
+                global.state.socket.send(JSON.stringify(message))
+                global.state.socket.close()
+            }
+        });
+    }
+
+}
+
+
+function print(...args){
+    const green ="#68f66e"
+    const blue ="#4284f5"
+    const yellow ="#fef972"
+    const red ="#ee6966"
+    const pink ="#fb7bfa"
+    const purple ="#6a76fa"
+
+    const colors = [green,blue,green,"white",green,blue,"white",yellow,blue,"white",yellow,"white",yellow,red,pink,purple];
+    console.log(`%c${args.join(' ')}`, ...colors.map(c => `color: ${c};`));
+    // console.log(colors.map(c => `%c${c}`).join(''), ...colors.map(c => `background: ${c};`));
+}
+
+
+export function printWatermark(name, git){
+    print(`                                            %c ${name}\n` +
+        "%c⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀        %c -----------------------------------\n" +
+        "%c⠀⠀⠀⠀⠀⠀⠀⢠⠀⠀⠀⠀⠀⠀⠀⠀⢰⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀       %c  Credits%c: Lou !  \n" +
+        `%c⠀⠀⠀⠀⠀⠀⠀⠸⣷⣦⣀⠀⠀⠀⠀⠀⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⡀⠀⠀        %c Git%c: ${git}\n` +
+        "%c⠀⠀⠀⠀⠀⠀⠀⠀⠙⣿⣿⣿⣦⠀⠠⠾⠿⣿⣷⠀⠀⠀⠀⠀⣠⣤⣄⠀⠀⠀\n" +
+        "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠟⢉⣠⣤⣶⡆⠀⣠⣈⠀⢀⣠⣴⣿⣿⠋⠀⠀⠀⠀      %c Powered by Vesta ! \n" +
+        "%c⠀⢀⡀⢀⣀⣀⣠⣤⡄⢀⣀⡘⣿⣿⣿⣷⣼⣿⣿⣷⡄⠹⣿⡿⠁⠀⠀⠀⠀⠀\n" +
+        "%c⠀⠀⠻⠿⢿⣿⣿⣿⠁⣼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣟⣁⠀⠋⠀⠀⠀⠀⠀⠀⠀ \n" +
+        "⠀⠀⠀⠀⠀⠀⠈⠻⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢰⣄⣀⠀⠀⠀⠀⠀\n" +
+        "%c⠀⠀ ⠀⠀⠀⠀⣠⡀⠀⣴⣿⣿⣿⣿⣿⣿⣿⡿⢿⡿⠀⣾⣿⣿⣿⣿⣶⡄⠀ \n" +
+        "⠀⠀⠀⠀⠀⢀⣾⣿⣷⡀⠻⣿⣿⡿⠻⣿⣿⣿⣿⠀⠀⠈⠉⠉⠉⠀⠀⠀⠀⠀\n" +
+        "⠀⠀⠀⠀⣠⣾⡿⠟⠉⠉⠀⢀⡉⠁⠀⠛⠛⢉⣠⣴⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀\n" +
+        "%c⠀⠀⠀⠈⠉⠉⠀⠀⠀⠀⠀⢸⣿⣿⡿⠉⠀⠙⠿⣿⣿⣧⡀⠀⠀⠀⠀⠀⠀⠀\n" +
+        "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⣿⠁⠀⠀⠀⠀⠀⠙⠿⣷⠀⠀⠀⠀⠀⠀⠀\n" +
+        "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠟⠀⠀⠀⠀⠀⠀⠀⠀⠃⠀⠀⠀⠀⠀⠀⠀")
+}
+
+export function hideLoadingScreen() {
+    const loadingScreen = document.getElementById('loading-screen');
+
+    // Fade out the loading screen
+    loadingScreen.classList.add('fade-out');
+
+    // Optional: wait until the transition ends before removing or showing content
+    loadingScreen.addEventListener('transitionend', () => {
+        loadingScreen.style.display = 'none';
+    });
+}

vesta/emptyProject/static/framework/templating.mjs

@@ -0,0 +1,110 @@
+let templates = {}
+
+export function xhr(endpoint,effect,method="GET", async=true, body=undefined){
+    let xhr= new XMLHttpRequest();
+    xhr.open(method, endpoint, async);
+    xhr.onload=effect
+    xhr.onerror = function() {
+        console.log("request failed")
+    };
+    if (body) {
+        xhr.setRequestHeader("Content-Type", "application/json");
+        xhr.send(JSON.stringify(body));
+    }else{
+        xhr.send();
+    }
+    return xhr
+}
+
+
+function loadTemplate(template, target=undefined, flex= undefined, async){
+    const effect = function() {
+        if (target){
+            //maybe not using eval
+            document.getElementById(target).innerHTML = eval('`' + this.responseText + '`');
+        }else{
+            global.state.dom.insertAdjacentHTML('beforeend',eval('`' + this.responseText + '`'))
+        }
+        if (flex){
+            document.getElementById(flex).style.display = "flex"
+        }
+    };
+
+    xhr( '/static/templates/'.concat(template), effect,"GET", async)
+}
+window.loadTemplate = loadTemplate
+
+function fillWith(template, list){
+    // console.log("fillWith",template,list,typeof list)
+
+    let request
+    if(templates[template]){
+        request={"responseText":templates[template]}
+    }else{
+        request = xhr( '/static/templates/'.concat(template,".html"), undefined, "GET", false)
+        // console.log("adding to cache",templates, template)
+        templates[template] = request.responseText
+    }
+
+    let content = ""
+    if (typeof list == 'object'){
+        for (let elementId in list){
+            const element = list[elementId]
+            content += eval('`' + request.responseText + '`')
+        }
+    }else if (!list){
+        console.warn("fillWith called with undefined list")
+        return content
+    }else{
+        for (let element of list){
+            content += eval('`' + request.responseText + '`')
+        }
+    }
+
+    return content
+}
+window.fillWith = fillWith
+
+function Subscribe(element, content, className=undefined, params=undefined){
+    //subscribe content to element, content will be reevaluated on element change
+    const domElement = document.createElement('div')
+    domElement.className = element.replaceAll('.','-').replaceAll('[','🪟').replaceAll(']','🥹')
+
+    if (className){
+        const classList = className.split(" ")
+        for (let name of classList){
+            domElement.classList.add(name)
+        }
+        domElement.dataset.defaultClass = domElement.className
+    }
+
+    if (params?.target === "class"){
+        domElement.dataset.target = params.target
+        domElement.className = domElement.className + " " + content()
+    }else if(params?.target === "style"){
+        domElement.dataset.target = params.target
+        domElement.style = content()
+    } else{
+        domElement.innerHTML = content()
+    }
+
+
+
+    if (params?.element){
+        domElement.dataset.element = params.element
+    }
+
+    if(params?.repaint){
+        domElement.dataset.repaint = params.repaint
+    }else{
+        domElement.dataset.content = content
+    }
+    return domElement.outerHTML
+}
+window.Subscribe = Subscribe
+
+function getTemplate(name){
+    const request = xhr( '/static/templates/'.concat(name,".html"), ()=>{}, "GET", false)
+    return eval('`' + request.responseText + '`')
+}
+window.getTemplate = getTemplate

vesta/emptyProject/static/framework/vesta.mjs

@@ -0,0 +1,173 @@
+function logout() {
+    const url = "/logout";
+    fetch(url, {
+        method: 'POST',
+        redirect: 'manual'
+    })
+        .then(response => {
+            const location = response.headers.get('location');
+            if (response.status === 302 && location) {
+                window.location.href = location;
+            } else {
+                // fallback: reload page or handle error
+                window.location.reload();
+            }
+        })
+        .catch(() => {
+            console.log("request failed");
+        });
+}
+window.logout = logout
+
+
+
+export function updateElement(selector,value=undefined){
+    const subscriptions = document.querySelectorAll(`[class^="${selector.replaceAll('.','-').replaceAll('[','🪟').replaceAll(']','🥹')}"]`)
+    for (let sub of subscriptions){
+        if(sub.dataset.repaint){
+            const fn = eval(sub.dataset.repaint)
+            fn()
+        }else if(sub.dataset.target === "class"){
+
+            const content = eval(sub.dataset.content)
+            if(sub.dataset.element){
+                sub.className = sub.dataset.defaultClass.concat(' ',content(eval(sub.dataset.element)))
+            }else{
+                sub.className = sub.dataset.defaultClass.concat(' ',content())
+            }
+        }else if(sub.dataset.target === "style"){
+            const content = eval(sub.dataset.content)
+            if(sub.dataset.element){
+                sub.style = content(eval(sub.dataset.element))
+            }else{
+                sub.style = content()
+            }
+        }else{
+
+            const content = eval(sub.dataset.content)
+            if(sub.dataset.element){
+                sub.innerHTML = content(eval(sub.dataset.element))
+            }else{
+                sub.innerHTML = content()
+            }
+        }
+    }
+}
+
+export function setElement(element, value){
+    // console.log(element,'has been updated to:', value);
+    eval(`${element} = value`);
+    updateElement(element,value)
+}
+
+export function pushElement(element, value){
+    // console.log(element,'has been added:', value);
+    eval(`${element}.push(value)`);
+    updateElement(element,value)
+}
+
+export function addElement(element, value){
+    // console.log(element,'has been added:', value);
+    eval(`${element}[value.id] = value`);
+    updateElement(element,value)
+}
+
+// this deletes an element from a list BY ID
+export function deleteElement(element, id){
+    // console.log(element,'has been removed:', element[id]);
+    eval(`${element}.splice(id,1)`);
+    updateElement(element)
+}
+
+// this deletes an element from a dict BY ID
+export function deleteElementDict(element, id){
+    // console.log(element,'has been removed:', element[id]);
+    eval(`delete ${element}[id]`);
+    updateElement(element)
+}
+
+// this deletes an element from a list BY VALUE
+export function deleteVal(element, val){
+    // console.log(element,'has been removed:', element[id]);
+    eval(`${element} = ${element}.filter(item => item !== val)`);
+    updateElement(element)
+}
+
+function checkEnter(event, effect){
+    if (event.key === "Enter"){
+        effect()
+    }
+}
+window.checkEnter = checkEnter
+
+function getTimeStr(timestamp, options = { locale: "fr-FR" }) {
+    const date = new Date(timestamp);
+
+    const defaultOptions = {
+        year: "numeric",
+        month: "numeric",
+        day: "numeric",
+        hour: "numeric",
+        minute: "numeric",
+        hour12: false,
+    };
+
+    const mergedOptions = { ...defaultOptions, ...options };
+    // console.log("TIMESTR",date.toLocaleDateString(undefined, mergedOptions))
+    return date.toLocaleDateString(undefined, mergedOptions);
+}
+window.getTimeStr = getTimeStr
+
+
+function goodbye(){
+    if (confirm('Voulez-vous vraiment vous désinscrire et supprimer votre compte de tous les services Carbonlab ? (toutes vos informations seront effacées)')) {
+        const url = "/goodbye";
+        let request = new XMLHttpRequest();
+        request.open('POST', url, true);
+        request.onload = function() { // request successful
+            console.log("account deleted")
+
+            if (request.response === 302){
+                window.location.href = request.response.headers.get('location');
+            }
+        };
+
+        request.onerror = function() {
+            console.log("request failed")
+        };
+
+        request.send();
+    } else {
+        console.log("ouf 😖")
+    }
+}
+window.goodbye = goodbye
+
+export function difference(arrKeys, dict) {
+    const result = [];
+    const dictKeys = new Set(Object.keys(dict)); // Convert dict keys to a set for efficient lookup
+
+    for (const key of arrKeys) {
+        if (!dictKeys.has(key.toString())) {
+            result.push(key);
+        }
+    }
+    return Array.from(result);
+}
+
+export function generateUUID() {
+    let d = new Date().getTime();//Timestamp
+    let d2 = ((typeof performance !== 'undefined') && performance.now && (performance.now()*1000)) || 0;//Time in microseconds since page-load or 0 if unsupported
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+        let r = Math.random() * 16;//random number between 0 and 16
+        if(d > 0){//Use timestamp until depleted
+            r = (d + r)%16 | 0;
+            d = Math.floor(d/16);
+        } else {//Use microseconds since page-load if supported
+            r = (d2 + r)%16 | 0;
+            d2 = Math.floor(d2/16);
+        }
+        return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+    });
+}
+

vesta/emptyProject/static/framework/websockets.mjs

@@ -0,0 +1,41 @@
+import global from "./global.mjs";
+import {onMessage} from "../ws/onMessage.mjs";
+import {WEBSOCKETS} from "/config";
+
+
+export function initWebSockets(){
+    global.state.websocket = new WebSocket(WEBSOCKETS);
+
+    global.state.websocket.onopen = function(event) {
+        if (!global.user.id) {
+            const cookie = document.cookie.split('; ').find(row => row.startsWith('client' + '='));
+            if (cookie) {
+                global.user['id'] = cookie.split('=')[1];
+            } else {
+                console.log("ERROR : INVALID SESSION",document);
+            }
+        }
+
+
+        console.log("Connection opened to Python WebSocket server!");
+        const message = {"type" : 'register', "uid": global.user.id};
+        global.state.websocket.send(JSON.stringify(message));
+    };
+
+    global.state.websocket.onmessage = onMessage;
+
+    global.state.websocket.onclose = function(event) {
+        console.log(`[WS] Connexion closed - Code: ${event.code}, Reason: ${event.reason}`);
+
+        if (event.code !== 1000 && event.code !== 1001) {
+            console.log("[WS] Trying to reconnect in 3 secondes...");
+            setTimeout(() => {
+                initWebSockets();
+            }, 3000);
+        }
+    };
+
+    global.state.websocket.onerror = function(error) {
+        console.error("WebSocket error:", error);
+    };
+}

vesta/emptyProject/static/markdown/markdown.mjs

@@ -0,0 +1,463 @@
+// This in absolutely no spec, it comes exclusively from my deranged mind
+
+export class Markdown {
+    constructor() {
+    }
+
+    HTML_equiv = {
+        "#":"<h${props.level}>${content}</h${props.level}>",
+        "text":"${content}",
+        "start li":"<li>${content}</li>",
+        "*":"<i>${content}</i>",
+        "**":"<b>${content}</b>",
+        ">":"<div class='answer'>${content}</div>",
+        "'''":"<div class='code-wrapper'><code>${content}</code><div class='circle grey' onclick='copyCode(event)'></div></div>",
+        "~~":"<div class='crossed'>${content}</div>",
+        "||":"<div class='spoiler' onclick='showSpoiler(event)'>${content}</div>",
+        "link":"<a href='${props.link}' target='_blank'>${content}</a>",
+        "color":"<div class='color' style='color: ${props.color}'>${content}</div>",
+        "endline":"\n",
+        "newline":"",
+        ")":")",
+        "'":"'",
+        "(":"(",
+        "/>":"/>",
+        "]":"]",
+        "/":"${content}/"
+    }
+
+    tokenize(str) {
+        const tokenList = []
+        let currentToken = new Token("newline")
+        let commitEndline = false
+
+        let char_id=0
+        while (char_id < str.length ){
+
+            //look for url
+            if(str.slice(char_id,char_id+6) === "https:" || str.slice(char_id,char_id+5) === "http:" ){
+                if (currentToken.content !== ""){
+                    tokenList.push(currentToken)
+                    currentToken = new Token("link")
+                }else{
+                    currentToken.type="link"
+                }
+
+                let look_id = 5
+                let nextToken
+                while (char_id+look_id<str.length){
+                    if(str[char_id+look_id]=== "\n"){
+                        nextToken = new Token("newline")
+                        look_id++
+                        break
+                    }
+                    if([" ",")","]"].includes(str[char_id+look_id])){
+                        nextToken = new Token("text")
+                        break
+                    }
+                    look_id++
+                }
+                currentToken.content = str.slice(char_id,char_id+look_id)
+                currentToken.props.link = currentToken.content
+                tokenList.push(currentToken)
+                if(char_id+look_id>=str.length){
+                    return tokenList;
+                }
+                char_id += look_id
+                currentToken = nextToken
+            }else{
+                const char = str[char_id]
+                switch (currentToken.type){
+                    case "text":
+                        switch (char){
+                            case '*':
+                                if (currentToken.content !== ""){
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("*")
+                                currentToken.props.level = 1
+                                break
+                            case '[':
+                            case ']':
+                            case '(':
+                            case ')':
+                                if (currentToken.content !== ""){
+                                    tokenList.push(currentToken)
+                                }
+                                tokenList.push(new Token(char))
+                                currentToken = new Token("text")
+                                break
+                            case '|':
+                            case '~':
+                            case "'":
+                            case '/':
+                            case '&':
+                            case '<':
+                                currentToken.type = char
+                                break
+                            case '\n':
+                                if (commitEndline){
+                                    commitEndline = false
+                                    tokenList.push(currentToken)
+                                    tokenList.push(new Token("endline"))
+                                    currentToken = new Token("newline")
+                                }else{
+                                    currentToken.content = currentToken.content.concat(char)
+                                    currentToken.props.consuming="text"
+                                    currentToken.type="newline"
+                                }
+                                break
+                            default:
+                                currentToken.content = currentToken.content.concat(char)
+                        }
+                        break
+                    case "#":
+                        switch (char){
+                            case '#':
+                                currentToken.props.level = currentToken.props.level<3 ? currentToken.props.level+1 : 3
+                                break
+                            case '\n':
+                                tokenList.push(currentToken)
+                                currentToken = new Token("newline")
+                                break
+                            default:
+                                currentToken.content = currentToken.content.concat(char)
+                        }
+                        break
+                    case "newline":
+                        switch (char){
+                            case '#':
+                                if (currentToken.content.trim() !== ""){
+                                    currentToken.type=currentToken.props.consuming
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("#")
+                                currentToken.props["level"] = 1
+                                break
+                            case '-':
+                                if (currentToken.content.trim() !== ""){
+                                    currentToken.type=currentToken.props.consuming
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("text")
+                                tokenList.push(new Token("start li"))
+                                commitEndline = true
+                                break
+                            case '>':
+                                if (currentToken.content.trim() !== ""){
+                                    currentToken.type=currentToken.props.consuming
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("text")
+                                tokenList.push(new Token(">"))
+                                commitEndline = true
+                                break
+                            case '*':
+                                currentToken = new Token("*")
+                                currentToken.props.level = 1
+                                break
+                            case '|':
+                            case '~':
+                            case "'":
+                            case '/':
+                            case '&':
+                            case '<':
+                                currentToken.type = char
+                                break
+                            case '[':
+                            case ']':
+                            case '(':
+                            case ')':
+                                tokenList.push(new Token(char))
+                                currentToken = new Token("text")
+                                break
+                            case ' ':
+                                currentToken.content = currentToken.content.concat(char)
+                                break
+                            case '\n':
+                                currentToken.type = "text"
+                                tokenList.push(currentToken)
+                                tokenList.push(new Token("endline"))
+                                currentToken = new Token("newline")
+                                break
+                            default:
+                                currentToken.type="text"
+                                currentToken.content = currentToken.content.concat(char)
+                        }
+                        break
+                    case "*":
+                        switch (char){
+                            case "*":
+                                currentToken.props.level = currentToken.props.level<3 ? currentToken.props.level+1 : 3
+                                break
+                            case '\n':
+                                tokenList.push(currentToken)
+                                currentToken = new Token("newline")
+                                currentToken.content = "\n"
+                                if (commitEndline) {
+                                    commitEndline = false
+                                }
+                                break
+                            case '|':
+                            case '~':
+                            case '/':
+                                tokenList.push(currentToken)
+                                currentToken = new Token(char)
+                                break
+                            default:
+                                tokenList.push(currentToken)
+                                currentToken = new Token("text")
+                                currentToken.content = currentToken.content.concat(char)
+                        }
+                        break
+                    case '|':
+                        switch (char){
+                            case "|":
+                                if (currentToken.content !== ""){
+                                    currentToken.type = "text"
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("||")
+                                tokenList.push(currentToken)
+                                currentToken = new Token("text")
+                                break
+                            default:
+                                currentToken.type="text"
+                                currentToken.content="|".concat(char)
+                        }
+                        break
+                    case '~':
+                        switch (char){
+                            case "~":
+                                if (currentToken.content !== ""){
+                                    currentToken.type = "text"
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("~~")
+                                tokenList.push(currentToken)
+                                currentToken = new Token("text")
+                                break
+                            default:
+                                currentToken.type="text"
+                                currentToken.content="~".concat(char)
+                        }
+                        break
+                    case "'":
+                        switch (char){
+                            case "'":
+                                if(!currentToken.props.level || currentToken.props.level<2){
+                                    currentToken.props.level = currentToken.props.level ? currentToken.props.level+1 : 2
+                                }else{
+                                    currentToken = new Token("'''")
+                                    currentToken.props.level=0
+                                }
+                                break
+                            default:
+                                currentToken.type = "text"
+                                currentToken.content = currentToken.content.concat("'",char)
+                        }
+                        break
+                    case "'''":
+                        switch (char){
+                            case "'":
+                                if(currentToken.props.level<2){
+                                    currentToken.props.level += 1
+                                }else{
+                                    tokenList.push(currentToken)
+                                    currentToken = new Token("text")
+                                }
+                                break
+                            default:
+                                if(currentToken.props.level !==0){
+                                    currentToken.content = currentToken.content.concat("'".repeat(currentToken.props.level))
+                                    currentToken.props.level = 0
+                                }
+                                currentToken.content = currentToken.content.concat(char)
+                        }
+                        break
+                    case "&":
+                        if(str.slice(char_id, char_id+3) === "lt;"){
+                            if (currentToken.content !== ""){
+                                currentToken.type = "text"
+                                tokenList.push(currentToken)
+                            }
+                            char_id+=2
+                            currentToken = new Token("<")
+                        }else{
+                            currentToken.content = currentToken.content.concat(char)
+                            currentToken.type = "text"
+                        }
+                        break
+                    case "<":
+                        switch (char){
+                            case "$":
+                                if (currentToken.content !== ""){
+                                    currentToken.type = "text"
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("color")
+                                currentToken.props.color=""
+                                break
+                            default:
+                                currentToken.type = "text"
+                                currentToken.content = currentToken.content.concat("&lt;", char)
+                        }
+                        break
+                    case "color":
+                        switch (char){
+                            case " ":
+                                tokenList.push(currentToken)
+                                currentToken = new Token("text")
+                                break
+                            case "\n":
+                                tokenList.push(currentToken)
+                                currentToken = new Token("newline")
+                                break
+                            default:
+                                currentToken.props.color = currentToken.props.color.concat(char)
+                        }
+                        break
+                    case "/":
+                        switch (char){
+                            case '>':
+                                if (currentToken.content !== ""){
+                                    currentToken.type = "text"
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("/>")
+                                tokenList.push(currentToken)
+                                currentToken = new Token("text")
+                                break
+                            default:
+                                currentToken.type = "text"
+                                currentToken.content = currentToken.content.concat("/", char)
+                        }
+                        break
+                }
+                char_id += 1
+            }
+        }
+        tokenList.push(currentToken)
+        return tokenList;
+    }
+
+    render(tokens) {
+        let result = ""
+        for(let token_id = 0;  token_id < tokens.length; token_id+=1){
+            const render = this.renderToken(tokens[token_id], token_id, tokens)
+            token_id = render[1]
+            result = result.concat(render[0])
+        }
+        return result;
+    }
+
+    renderToken(token, token_id, tokens){
+        // console.log("render token",token,token_id,tokens)
+        const old_id = token_id
+        let content = ""
+        switch(token.type) {
+            case ">":
+            case "start li":
+                while (token_id + 1 < tokens.length && tokens[token_id + 1].type !== "endline") {
+                    token_id += 1
+                    const render = this.renderToken(tokens[token_id], token_id, tokens)
+                    token_id = render[1]
+                    content = content.concat(render[0])
+                }
+                token.content = content
+                return [fillTemplate(this.HTML_equiv[token.type], token), token_id+1]
+            case "*":
+                // this is suboptimal because we're looking for same size closing
+                // smth like *** a ** b * will not work as intended
+                while (token_id + 1 < tokens.length && tokens[token_id + 1].type !== "endline") {
+                    token_id += 1
+                    if(tokens[token_id].type === "*" && tokens[token_id].props.level === token.props.level){
+                        token.content = content
+                        if (token.props.level % 2) {
+                            if (token.props.level === 3) {
+                                token.content = fillTemplate(this.HTML_equiv["**"], token)
+                            }
+                            return [fillTemplate(this.HTML_equiv["*"], token), token_id]
+                        } else {
+                            return [fillTemplate(this.HTML_equiv["**"], token), token_id]
+                        }
+                    }
+                    const render = this.renderToken(tokens[token_id], token_id, tokens)
+                    token_id = render[1]
+                    content = content.concat(render[0])
+                }
+                token.content = "*".repeat(token.props.level)
+                // should be optimized, because we just drop a part of the render here
+                return [fillTemplate(this.HTML_equiv["text"], token), old_id]
+            case "~~":
+            case "||":
+                while (token_id + 1 < tokens.length) {
+                    token_id += 1
+                    if(tokens[token_id].type === token.type){
+                        token.content = content
+                        return [fillTemplate(this.HTML_equiv[token.type], token), token_id]
+                    }
+                    const render = this.renderToken(tokens[token_id], token_id, tokens)
+                    token_id = render[1]
+                    content = content.concat(render[0])
+                }
+                token.content = token.type
+                return [fillTemplate(this.HTML_equiv["text"], token), old_id]
+            case "[":
+                while (token_id + 1 < tokens.length) {
+                    token_id += 1
+                    if(tokens[token_id].type === "\n"){
+                        break
+                    }
+                    if(tokens[token_id].type === "]"){
+                        if(tokens[token_id+1].type === "(" && tokens[token_id+2].type === "link" && tokens[token_id+3].type === ")"){
+                            token.content = content
+                            token.props.link = tokens[token_id+2].content
+                            return [fillTemplate(this.HTML_equiv["link"], token), token_id+3]
+                        }else{
+                            break
+                        }
+                    }
+                    const render = this.renderToken(tokens[token_id], token_id, tokens)
+                    token_id = render[1]
+                    content = content.concat(render[0])
+                }
+                token.content = token.type
+                return [fillTemplate(this.HTML_equiv["text"], token), old_id]
+            case "color":
+                while (token_id + 1 < tokens.length) {
+                    token_id += 1
+                    if(tokens[token_id].type === "/>"){
+                        token.content = content
+                        return [fillTemplate(this.HTML_equiv[token.type], token), token_id]
+                    }
+                    const render = this.renderToken(tokens[token_id], token_id, tokens)
+                    token_id = render[1]
+                    content = content.concat(render[0])
+                }
+                token.type="text"
+                token.content = "<$"+token.props?.color
+                return [fillTemplate(this.HTML_equiv[token.type], token), token_id]
+            default:
+                return [fillTemplate(this.HTML_equiv[token.type], token), token_id]
+        }
+    }
+}
+
+class Token{
+    constructor(type) {
+        this.type = type
+        this.content=""
+        this.props={}
+    }
+}
+
+const fillTemplate = (template, vars = {}) => {
+    const handler = new Function('vars', [
+        'const tagged = ( ' + Object.keys(vars).join(', ') + ' ) =>',
+        '`' + template + '`',
+        'return tagged(...Object.values(vars))'
+    ].join('\n'));
+    const res = handler(vars)
+    return res;
+};

vesta/emptyProject/static/markdown/utils.mjs

@@ -0,0 +1,21 @@
+import {Markdown} from "./markdown.mjs";
+
+export function MDToHTML(text){
+    const engine = new Markdown()
+    const tokens = engine.tokenize(text)
+    console.log("text",text,"tokens",tokens)
+    return engine.render(tokens)
+}
+window.MDToHTML = MDToHTML
+
+export function showSpoiler(event){
+    event.currentTarget.classList.toggle("clicked")
+}
+window.showSpoiler = showSpoiler
+
+export function copyCode(event){
+    navigator.clipboard.writeText(event.currentTarget.parentElement.firstElementChild.innerHTML).then(
+        event.currentTarget.style.background = "var(--green)"
+    )
+}
+window.copyCode = copyCode

{vesta_web-1.1.0.dist-info → vesta_web-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vesta-web
-Version: 1.1.0
+Version: 1.1.1
 Summary: An extensive web framework adding every feature needed for Carbonlab
 Project-URL: Homepage, https://gitlab.com/Louciole/vesta
 Project-URL: Issues, https://gitlab.com/Louciole/vesta/-/issues

{vesta_web-1.1.0.dist-info → vesta_web-1.1.1.dist-info}/RECORD

@@ -28,11 +28,18 @@ vesta/emptyProject/static/main.html,sha256=zsQF82JQ67Tms9AEPW9tZLVClVTlVX2uPGPiL
 vesta/emptyProject/static/main.mjs,sha256=1j5antaPx8aUhuULg0YEMH3zNuJQyWxKTHUcGbQiyBc,396
 vesta/emptyProject/static/mobileUiManifest.mjs,sha256=IwSGmWykI_KHASJ-IzvOkQUP8mmT8_J8BIVa1ro0aso,30
 vesta/emptyProject/static/style.css,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vesta/emptyProject/static/framework/global.mjs,sha256=Zr3F9E_DfyYzxqYfdeSBCTezf42VNUqkWR1zB3Py_Tw,124
+vesta/emptyProject/static/framework/navigation.mjs,sha256=EMI-bTJDp0XqTWxHQkZKyT-u5Q9cKA6QVkF4hJyKrRY,11119
+vesta/emptyProject/static/framework/templating.mjs,sha256=v0w-JtkOoSgHWAy7_A24jZzvBQ99f5FBii2RrykUAkU,3319
+vesta/emptyProject/static/framework/vesta.mjs,sha256=0YrLyt4US22TIknO3OFWeOQuWimIWLBwMFCoKzBEHX4,5459
+vesta/emptyProject/static/framework/websockets.mjs,sha256=Ck0bdEj0mVU3PHZ1MtPPz2He47OYl2WmRxqE3NSKh-c,1349
 vesta/emptyProject/static/home/auth.css,sha256=Vw-wFyQJm1ydDVBHPdKWp4dvzrfFRry4-kgScVFleOM,1924
 vesta/emptyProject/static/home/auth.html,sha256=sz-CC-B4NUqth8aSQqwQCvq2V46AnhaIIcGHRU6Wyl8,1836
 vesta/emptyProject/static/home/auth.js,sha256=txMlUqr4A-15Czf4MYwaED35XXcaHI_zrc4SpnjItJU,4622
 vesta/emptyProject/static/home/reset.html,sha256=EcXfX2Vil3NrYhDvEptrIhW9QV9X_kDy59-TK2S_P4w,2655
 vesta/emptyProject/static/home/verif.html,sha256=tUw96l0FZ5-AXuE8s-7v1nM632onErq5swgCU53zP-s,2906
+vesta/emptyProject/static/markdown/markdown.mjs,sha256=gpSUS-8UUJYb_sahgnrobqMvtlYpS2Q-AaE-RUeqIyA,21469
+vesta/emptyProject/static/markdown/utils.mjs,sha256=PGxhsJfub_lt-LEZVqYt8lKEp_RTRVGXuNhGmWxto-k,614
 vesta/emptyProject/static/translations/en.mjs,sha256=ouMluPVTgB4Q5vmb7zGE6YGTH4URruog5_a52sBDYNE,22
 vesta/emptyProject/static/translations/fr.mjs,sha256=ouMluPVTgB4Q5vmb7zGE6YGTH4URruog5_a52sBDYNE,22
 vesta/emptyProject/static/translations/translation.mjs,sha256=JxJ2peSlYVQK-bUKpfddPLXm0XZiz2yu6A6iWIqpKyM,1422
@@ -48,8 +55,8 @@ vesta/scripts/install.py,sha256=GvH_HHx5aU5_54RQ1_2vz4DaLCh42AHfUKy-m0q21vY,2125
 vesta/scripts/testsRun.py,sha256=PQkxKyCwM-TGu9KbLSIkz70o5jnGQSf5aFN9Gil3_1U,2459
 vesta/scripts/utils.py,sha256=MQZ29b4eplF0OR9EimUToOO73CVoV_cTxQeez2F3OoY,3460
 vesta/scripts/vesta.py,sha256=xfY-dVzPAbJdmgpRJoGGNSlSXDsMyrQPwykAK017YqE,7506
-vesta_web-1.1.0.dist-info/METADATA,sha256=I-6cYJ8MCIeqT-l5fbPmtkWLn8niwHFWPB0jYTkAGxo,1558
-vesta_web-1.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-vesta_web-1.1.0.dist-info/entry_points.txt,sha256=_x509HUdPeKL_Fja0OqUuDa8zKGeLndMxIE_IfojlJg,51
-vesta_web-1.1.0.dist-info/licenses/LICENSE.md,sha256=zoPFEFUUoSgosmDBK5fGTWGRHHBaSVuuJT2ZQIYXuIk,177
-vesta_web-1.1.0.dist-info/RECORD,,
+vesta_web-1.1.1.dist-info/METADATA,sha256=avBj6zSXwT0FDvjBkpk36sMrjF2hLChFn8-TEB_4RC0,1558
+vesta_web-1.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+vesta_web-1.1.1.dist-info/entry_points.txt,sha256=_x509HUdPeKL_Fja0OqUuDa8zKGeLndMxIE_IfojlJg,51
+vesta_web-1.1.1.dist-info/licenses/LICENSE.md,sha256=zoPFEFUUoSgosmDBK5fGTWGRHHBaSVuuJT2ZQIYXuIk,177
+vesta_web-1.1.1.dist-info/RECORD,,