drakongen 1.0.0

package/src/structFlow.js

@@ -0,0 +1,382 @@
+var {buildTree} = require("./technicalTree")
+const { createError, sortByProperty } = require("./tools");
+
+function redirectNode(nodes, node, from, to) {
+    if (node.one === from) {
+        node.one = to;
+    }
+    if (node.two === from) {
+        node.two = to;
+    }
+    if (node.next === from) {
+        node.next = to
+    }
+    if (node.start && node.type === "loopend") {
+        start = nodes[node.start]
+        if (start.next === from) {
+            start.next = to
+        }
+    }
+}
+
+function structFlow(nodes, branches, filename, translate) {
+
+
+
+    function flowGraph(nodes, nodeId, branchingStack) {
+        if (!nodeId) {return;}
+
+        const node = nodes[nodeId];
+
+        if (!node.stack) {
+            node.stack = [];
+            node.remaining = node.prev.length;
+        }
+        node.remaining--;
+
+        mergeBranchingStack(nodes, node, branchingStack);
+        if (node.remaining > 0) {return;}       
+
+        if (node.type === "question") {
+            for (let i = 0; i < node.stack.length; i++) {
+                const questionId = node.stack[i];
+                const question = nodes[questionId];
+                question.branching++;
+            }
+
+            const stackOne = node.stack.slice();
+            const stackTwo = node.stack.slice();
+            stackOne.push(nodeId);
+            stackTwo.push(nodeId);
+
+            flowGraph(nodes, node.two, stackTwo);
+            flowGraph(nodes, node.one, stackOne);
+        } else if (node.type === "arrow-loop") {
+            const stackOne = node.stack.slice();
+            stackOne.push(nodeId);
+            flowGraph(nodes, node.one, stackOne);
+        } else if (node.type === "arrow-stub") {
+            decrementBranchingForArrow(nodes, node)
+        } else {
+            flowGraph(nodes, node.one, node.stack);
+        }
+    }
+
+    function decrementBranchingForArrow(nodes, node) {        
+        var algonode = nodes[node.arrow]
+        algonode.branching--        
+    }
+
+    function decrementQuestions(nodes, algonode, dictionary) {
+        var stub = nodes[algonode.stub]
+        for (var id of stub.stack) {
+            var snode = nodes[id]
+            if (id != algonode) {
+                if (id in dictionary) {
+                    snode.branching--
+                }
+            }
+        }
+        return stub
+    }
+
+
+
+    function mergeBranchingStack(nodes, node, branchingStack) {
+        // Append all elements of the branching stack to node.stack
+        addRange(node.stack, branchingStack)
+
+        // Build a dictionary of occurrences
+        const dictionary = buildDictionaryOfOccurences(node);
+
+        // Merge all nodes
+        mergeAll(nodes, node, dictionary);
+
+        // Rebuild the stack
+        node.stack = buildStackFromDictionary(dictionary);
+    }
+
+    function addRange(dst, src) {
+        for (let i = 0; i < src.length; i++) {
+            dst.push(src[i]);
+        }
+    }
+
+    function buildStackFromDictionary(dictionary) {
+        const rebuiltStack = [];
+        for (const id in dictionary) {
+            if (dictionary[id] > 0) {
+                rebuiltStack.push(id);
+            }
+        }
+        return rebuiltStack;
+    }
+
+    function buildDictionaryOfOccurences(node) {
+        const dictionary = {};
+        for (let i = 0; i < node.stack.length; i++) {
+            const id = node.stack[i];
+            dictionary[id] = (dictionary[id] || 0) + 1;
+        }
+        return dictionary;
+    }
+
+    function mergeAll(nodes, node, dictionary) {
+        for (const id in dictionary) {
+            const occurrences = dictionary[id];
+            const algonode = nodes[id];
+            if (occurrences > 1) {
+                algonode.branching--;
+                dictionary[id] = occurrences - 1;
+            }
+            if (algonode.branching === 1) {
+                if (algonode.type === "arrow-loop" && !algonode.next) {
+                    if (!isInMap(node.astack, id)) {
+                        algonode.next = node.id
+                        dictionary[algonode.id] = 0;
+                        var stub = decrementQuestions(nodes, algonode, dictionary)
+                        stub.one = node.id
+                    }
+                }                
+            }            
+        }
+      
+        for (const id in dictionary) {
+            const algonode = nodes[id];
+            if (algonode.branching === 1) {
+                if (algonode.type === "question") {
+                    algonode.next = node.id;
+                    dictionary[algonode.id] = 0;
+                }                
+            }
+        }
+    }
+    function isInMap(map, key) {
+        if (!map) { return false }
+        return key in map
+    }
+
+    function prepareQuestions(nodes) {
+        for (const nodeId in nodes) {
+            const node = nodes[nodeId];
+            if (node.type === "question") {
+                node.branching = 2;
+            } else if (node.type === "arrow-loop") {
+                node.branching = 1;
+            }
+        }
+    }
+
+    function rewireArrows(nodes, branches) {
+        branches.forEach(branch => rewireArrowsInBranch(nodes, branch.id, branch.next, []))
+        for (var id in nodes) {
+            var node = nodes[id]
+            if (node.type === "arrow-loop") {
+                var stub = insertArrowStub(nodes, node)
+                fillAStack(nodes, stub, stub.arrow)
+            }
+        }    
+    }
+    
+    function fillAStack(nodes, node, arrowId) {
+        if (!node.astack) {
+            node.astack = {}
+        }
+        node.astack[arrowId] = true
+        if (node.id === arrowId) {
+            return
+        }    
+        for (var prevId of node.prev) {
+            var prev = nodes[prevId]
+            fillAStack(nodes, prev, arrowId)
+        }
+    }
+    
+    function rewireArrowsInBranch(nodes, prevNodeId, nodeId, arrowStack) {
+        if (!nodeId) {return}
+        var node = nodes[nodeId]
+        if (node.type === "branch") {
+            return
+        }
+        if (node.type === "arrow-loop") {
+            if (!node.noloop) {
+                node.noloop = {}
+            }
+            if (arrowStack.includes(nodeId)) {
+                return            
+            }
+            node.noloop[prevNodeId] = true
+            arrowStack = arrowStack.slice()
+            arrowStack.push(nodeId)
+            rewireArrowsInBranch(nodes, nodeId, node.one, arrowStack)
+        } else if (node.type === "question") {
+            var left = arrowStack.slice()
+            var right = arrowStack.slice()
+            rewireArrowsInBranch(nodes, nodeId, node.one, left)
+            rewireArrowsInBranch(nodes, nodeId, node.two, right)
+        } else {
+            rewireArrowsInBranch(nodes, nodeId, node.one, arrowStack)
+        }
+    }
+    
+    function insertArrowStub(nodes, node) {
+        var stub = {
+            type: "arrow-stub",
+            id: "arrow-stub-" + node.id,
+            arrow: node.id,
+            prev: []
+        }
+        nodes[stub.id] = stub
+        node.stub = stub.id
+        var prev2 = []
+        for (var prevId of node.prev) {
+            if (prevId in node.noloop) {
+                prev2.push(prevId)
+            } else {
+                stub.prev.push(prevId)
+                var prev = nodes[prevId]
+                redirectNode(nodes, prev, node.id, stub.id)
+            }
+        }
+        node.prev = prev2
+        return stub
+    }
+
+    function rewriteTree(body, index, endId, output) {
+        while (index < body.length) {
+            var node = body[index]
+            index++
+            if (endId && node.id === endId) {
+                return index
+            }
+            if (node.type === "question") {
+                var transformed = rewriteQuestionTree(node, output)
+                if (endId) {                    
+                    var breakYes = findLoopEnd(transformed.yes, endId)
+                    var breakNo = findLoopEnd(transformed.no, endId) 
+                    if (breakYes || breakNo) {
+                        var toBreak = []
+                        findPlacesToBreak(transformed.yes, endId, toBreak)
+                        findPlacesToBreak(transformed.no, endId, toBreak)                        
+                        addBreaks(toBreak)
+                        return index    
+                    }
+                }
+            } else if (node.type === "loopbegin") {
+                var body2 = []
+                index = rewriteTree(body, index, node.end, body2)
+                output.push({
+                    id: node.id,
+                    type: "loop",
+                    content: node.content,
+                    body: body2
+                })
+            } else {
+                output.push(node)
+            }
+        }
+    }
+
+    function findPlacesToBreak(body, endId, output) {
+        if (body.length === 0) {
+            output.push(body)
+            return
+        }
+        var last = body[body.length - 1]
+        if (last.id === endId) {
+            return
+        }
+        if (last.type === "question") {
+            var qends = []
+            findPlacesToBreak(last.yes, endId, qends)
+            findPlacesToBreak(last.no, endId, qends)
+            if (qends.length === 2
+                && qends[0] === last.yes
+                && qends[1] === last.no) {
+                output.push(body)                
+            } else {
+                addRange(output, qends)
+            }
+        } else {
+            output.push(body)
+        }
+    }
+
+    function findLoopEnd(body, endId) {
+        for (var i = 0; i < body.length; i++) {
+            var node = body[i]
+            if (node.id === endId) {
+                if (i === body.length - 1) {
+                    return true
+                } else {
+                    throw createError(
+                        translate("An exit from the loop must lead to the point right after the loop end"),
+                        filename,
+                        node.id
+                    );
+                }
+            }
+            if (node.type === "question") {
+                if (findLoopEnd(node.yes, endId)) {
+                    return true
+                }
+                if (findLoopEnd(node.no, endId)) {
+                    return true
+                }                
+            }            
+        }
+        return false
+    }
+
+    function addBreaks(toBreak) {
+        for (var body of toBreak) {
+            body.push({
+                type: "break"
+            })
+        }
+    }
+
+    function rewriteQuestionTree(question, output) {
+        var yes = []
+        var no = []
+        rewriteTree(question.yes, 0, undefined, yes)
+        rewriteTree(question.no, 0, undefined, no)
+        var transformed = {
+            type: "question",
+            id: question.id,
+            content: question.content,
+            yes: yes,
+            no: no
+        }
+        output.push(transformed)
+        return transformed
+    }
+    
+
+    function structMain() {
+        rewireArrows(nodes, branches)
+        prepareQuestions(nodes)    
+        var result = []
+        for (var branch of branches) {
+            flowGraph(nodes, branch.next, [])
+        }
+        
+        for (var branch of branches) {
+            var body = []
+            buildTree(nodes, branch.next, body, "<dummy id>")
+            var body2 = []
+            rewriteTree(body, 0, undefined, body2)
+            result.push({
+                name: branch.content,
+                branchId: branch.branchId,
+                start: branch.next,
+                body: body2
+            })
+        }
+
+        return sortByProperty(result, "branchId")
+    }
+
+    return structMain()
+}
+module.exports = { structFlow, redirectNode };

package/src/technicalTree.js

@@ -0,0 +1,84 @@
+function buildTree(nodes, nodeId, body, stopId) {
+    while (nodeId) {
+        if (nodeId === stopId) {return;}
+        const node = nodes[nodeId];
+        let transformed;
+        let next;
+
+        if (node.type === "question") {
+            next = reserveNext(nodes, node)
+
+            transformed = {
+                id: node.id,
+                type: "question",
+                content: node.content || "",
+                yes: [],
+                no: []
+            };
+
+            const yesNodeId = node.flag1 === 1 ? node.one : node.two;
+            const noNodeId = node.flag1 === 1 ? node.two : node.one;
+
+            buildTree(nodes, yesNodeId, transformed.yes, node.next);
+            buildTree(nodes, noNodeId, transformed.no, node.next);
+        } else if (node.type === "arrow-loop") {
+            transformed = {
+                id: node.id,
+                type: "loopbegin",
+                content: "",
+                end: node.stub
+            };
+
+            next = node.one;
+        } else if (node.type === "arrow-stub") {
+            transformed = {
+                id: node.id,
+                type: "loopend",
+                start: node.arrow
+            };
+
+            next = node.one;
+        } else {
+            transformed = {
+                id: node.id,
+                type: node.type,
+            }
+            copyFields(
+                transformed,
+                node,
+                [
+                    "content",
+                    "secondary",
+                    "start",
+                    "message",
+                    "end"
+                ]
+            )
+            next = node.one;
+        }
+
+        body.push(transformed);
+        nodeId = next;
+    }
+}
+
+function copyFields(dst, src, fields) {
+    for (var field of fields) {
+        var value = src[field]
+        if (value !== "" && value !== undefined && value !== null) {
+            dst[field] = value
+        }
+    }
+}
+
+function reserveNext(nodes, node) {
+    const target = nodes[node.next];
+    if (target.targetTaken) {
+        return undefined;
+    } else {
+        target.targetTaken = true;
+        return node.next;
+    }    
+}
+
+module.exports = {buildTree}

package/src/tools.js

@@ -0,0 +1,36 @@
+
+function createError(message, filename, nodeId) {
+    var error = new Error(message)
+    error.nodeId = nodeId
+    error.filename = filename
+    return error
+}
+
+function sortByProperty(array, property, order = "asc") {
+    if (!Array.isArray(array)) {
+        throw new Error("First argument must be an array");
+    }
+
+    return array.slice().sort((a, b) => {
+        const valA = a[property];
+        const valB = b[property];
+
+        if (valA === null || valB === null || valA === undefined || valB === undefined) {
+            return 0; // Handle null or undefined values
+        }
+
+        if (valA < valB) {
+            return order === "asc" ? -1 : 1;
+        }
+        if (valA > valB) {
+            return order === "asc" ? 1 : -1;
+        }
+        return 0; // Values are equal
+    });
+}
+function addRange(to, from) {
+    for (var item of from) {
+        to.push(item)
+    }
+}
+module.exports = { createError, sortByProperty, addRange }

package/src/translate.js

@@ -0,0 +1,108 @@
+var translationsRu = {
+    "error": "ОШИБКА",
+    "not": "не",
+    break: 'выход из цикла',
+    "and": "и",
+    "or": "или",
+    "if": "Если",
+    "else": "Иначе",
+    "empty": "ПУСТОЙ",
+    "loop forever": "Бесконечный цикл",
+    "pass": "Пропустить",
+    "Only the rightmost Case icon can be empty": "Только самая правая икона Вариант может быть пустой",
+    "Error parsing JSON": "Ошибка парсинга JSON",
+    "A Loop begin icon must have content": "Икона начала цикла ДЛЯ должна содержать данные",
+    "A Question icon must have content": "Икона Вопрос должна содержать данные",
+    "A Select icon must have content": "Икона Выбор должна содержать данные",
+    "Loop end expected here": "Здесь ожидается конец цикла",
+    "An exit from the loop must lead to the point right after the loop end": "Выход из цикла должен вести в точку сразу за его концом",
+    "A silhouette branch is not referenced": "Нет ссылок на ветку силуэта",
+    "Call subroutine": "Вызвать подпрограмму",
+    "Procedure": "Процедура",
+    "End of procedure": "Конец процедуры",
+    "Subroutine": "Подпрограмма",
+    "End of subroutine": "Конец подпрограммы",
+    "Description": "Описание",
+    "Algorithm": "Алгоритм",
+    Remarks: "Замечания"
+}
+
+var translationsEn = {
+    error: 'Error',
+    not: 'not',
+    break: 'break',
+    and: 'and',
+    or: 'or',
+    if: 'If',
+    else: 'Else',
+    empty: 'Empty',
+    'loop forever': 'Loop forever',
+    pass: 'Pass',
+    'Only the rightmost Case icon can be empty': 'Only the rightmost Case icon can be empty',
+    'Error parsing JSON': 'Error parsing JSON',
+    'A Loop begin icon must have content': 'A Loop begin icon must have content',
+    'A Question icon must have content': 'A Question icon must have content',
+    'A Select icon must have content': 'A Select icon must have content',
+    'Loop end expected here': 'Loop end expected here',
+    'An exit from the loop must lead to the point right after the loop end': 'An exit from the loop must lead to the point right after the loop end',
+    'A silhouette branch is not referenced': 'A silhouette branch is not referenced',
+    'Call subroutine': 'Call subroutine',
+    Procedure: 'Procedure',
+    'End of procedure': 'End of procedure',
+    Subroutine: 'Subroutine',
+    'End of subroutine': 'End of subroutine',
+    Description: 'Description',
+    Algorithm: 'Algorithm',
+    Remarks: "Remarks"
+}
+
+var translationsNo = {
+    error: 'Feil',
+    not: 'ikke',
+    break: 'avslutt løkken',
+    and: 'og',
+    or: 'eller',
+    if: 'Hvis',
+    else: 'Ellers',
+    empty: 'Tom',
+    'loop forever': 'Gjør evig',
+    pass: 'Hopp over',
+    'Only the rightmost Case icon can be empty': 'Bare den ytterste høyre Case-ikonet kan være tomt',
+    'Error parsing JSON': 'Feil ved parsing av JSON',
+    'A Loop begin icon must have content': 'Et Loop-startikon må ha innhold',
+    'A Question icon must have content': 'Et Spørsmål-ikon må ha innhold',
+    'A Select icon must have content': 'Et Velg-ikon må ha innhold',
+    'Loop end expected here': 'Slutt på løkke forventet her',
+    'An exit from the loop must lead to the point right after the loop end': 'En utgang fra løkken må føre til punktet rett etter løkkens slutt',
+    'A silhouette branch is not referenced': 'En silhuettgren er ikke referert',
+    'Call subroutine': 'Kall delprosedyre',
+    Procedure: 'Prosedyre',
+    'End of procedure': 'Slutt på prosedyre',
+    Subroutine: 'Delprosedyre',
+    'End of subroutine': 'Slutt på delprosedyre',
+    Description: 'Beskrivelse',
+    Algorithm: 'Algoritme',
+    Remarks: "Bemerkninger"
+};
+
+
+var translations = translationsEn
+
+function translate(text) {
+    return translations[text] || text;
+}
+
+function setUpLanguage(language) {
+    if (language === "ru") {
+        translations = translationsRu
+    } else if (language === "no") {
+        translations = translationsNo
+    } else if (language === "en") {
+        translations = translationsEn
+    } else {
+        translations = {}
+    }
+}
+
+
+module.exports = { setUpLanguage, translate };