libreqda 1.2.0__py3-none-any.whl

taguette/static/js/highlight/loader.js

@@ -0,0 +1,109 @@
+let highlightResizeObserver = null;
+
+function loadDocumentHighlights(document_id, highlight_id, splitParagraphs, search_text) {
+    if (document_id === null) {
+        document_contents.style.direction = 'ltr';
+        document_contents.innerHTML = '<p style="font-style: oblique; text-align: center;">' +
+            gettext("Load a document on the left") + '</p>';
+        toggleToolbarActions(false);
+        return;
+    }
+
+    showSpinner();
+
+    const info = getJSON(`/api/project/${project_id}/document/${document_id}`);
+    const contents = getJSON(`/api/project/${project_id}/document/${document_id}/contents`);
+
+    Promise.all([info, contents])
+        .then(function(results) {
+            const info = results[0];
+            const contents = results[1];
+
+            document_contents.innerHTML = '';
+            highlights = {};
+
+            if (highlightResizeObserver) {
+                highlightResizeObserver.disconnect();
+                highlightResizeObserver = null;
+            }
+
+            const mainContainer = document.createElement('div');
+            mainContainer.style.position = 'relative';
+            mainContainer.style.width = '100%';
+
+            const contentDiv = document.createElement('div');
+            contentDiv.id = 'highlight-content';
+            contentDiv.style.userSelect = 'text';
+            contentDiv.style.position = 'relative';
+            contentDiv.style.direction = info.text_direction === 'RIGHT_TO_LEFT' ? 'rtl' : 'ltr';
+            contentDiv.style.padding = '20px';
+            contentDiv.style.lineHeight = '1.6';
+
+            const allHTML = contents.contents.map((chunk, index) => {
+                return `<div id="doc-offset-${chunk.offset}" class="document-chunk" data-chunk-index="${index}">${chunk.contents}</div>`;
+            }).join('\n');
+
+            contentDiv.innerHTML = allHTML;
+            disableEditing(contentDiv);
+            addDragFunctionality(contentDiv);
+            mainContainer.appendChild(contentDiv);
+
+            // SVG overlay drawn on top of text — pointer-events: none so it doesn't block selection
+            const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+            svg.id = 'highlights-overlay';
+            svg.style.position = 'absolute';
+            svg.style.top = '0';
+            svg.style.left = '0';
+            svg.style.width = '100%';
+            svg.style.height = '100%';
+            svg.style.pointerEvents = 'none';
+            svg.style.zIndex = '9';
+            svg.style.overflow = 'visible';
+
+            mainContainer.appendChild(svg);
+            document_contents.appendChild(mainContainer);
+
+            for (const element of info.highlights) {
+                const id = '' + element.id;
+                highlights[id] = element;
+            }
+
+            requestAnimationFrame(() => {
+                requestAnimationFrame(() => {
+                    try {
+                        renderHighlights(Object.values(highlights));
+                    } catch (error) {
+                        log("Error rendering highlights", 'error', error);
+                    }
+                });
+            });
+
+            let _resizeTimeout = null;
+            highlightResizeObserver = new ResizeObserver(() => {
+                if (_renderingInProgress) return;
+                if (_resizeTimeout) clearTimeout(_resizeTimeout);
+                _resizeTimeout = setTimeout(() => {
+                    try {
+                        renderHighlights(Object.values(highlights));
+                    } catch (error) {
+                        log("Error re-rendering on resize", 'error', error);
+                    }
+                }, 300);
+            });
+            highlightResizeObserver.observe(contentDiv);
+
+            current_document = document_id;
+            toggleToolbarActions(true);
+            updateDocumentLinkHighlight(current_document);
+            updateDocumentExportButton(project_id, document_id);
+            updateLinksTarget(document_contents);
+
+            setTimeout(() => scrollToHighlight(highlight_id, search_text), 200);
+        })
+        .catch(function(error) {
+            log("Failed to load document", 'error', error);
+            const loadDocumentErrorMessage = gettext("Error loading document!");
+            showAlert(`${loadDocumentErrorMessage} \n\n`, 'error');
+        })
+        .then(hideSpinner);
+}

taguette/static/js/highlight/renderer.js

@@ -0,0 +1,405 @@
+const LINE_HEIGHT = 3;
+const LINE_GAP = 2;
+const BASE_OFFSET = 2;
+
+let _renderingInProgress = false;
+
+function renderHighlights(hlList) {
+    const container = document.getElementById('highlight-content');
+    const svg = document.getElementById('highlights-overlay');
+    if (!svg || !container) return;
+
+    _renderingInProgress = true;
+
+    const targets = getBlockTargets(container);
+    targets.forEach(el => { el.style.lineHeight = ''; });
+
+    // Pre-compute shared data once
+    const textNodes = collectTextNodes(container);
+    const { fullText, charMap } = buildCharMap(textNodes);
+    const utf8Map = buildUTF8ToCharMap(fullText);
+
+    const targetMaxLanes = estimateMaxLanesPerTarget(hlList, targets, container, textNodes, fullText, utf8Map);
+
+    let layoutChanged = false;
+    targetMaxLanes.forEach((maxLanes, el) => {
+        const newLH = (1.6 + maxLanes * 0.18) + 'em';
+        if (el.style.lineHeight !== newLH) {
+            el.style.lineHeight = newLH;
+            layoutChanged = true;
+        }
+    });
+
+    if (layoutChanged) {
+        requestAnimationFrame(() => {
+            requestAnimationFrame(() => {
+                drawHighlights(hlList, container, svg, charMap, fullText, utf8Map);
+                _renderingInProgress = false;
+            });
+        });
+    } else {
+        drawHighlights(hlList, container, svg, charMap, fullText, utf8Map);
+        _renderingInProgress = false;
+    }
+}
+
+function estimateMaxLanesPerTarget(hlList, targets, container, textNodes, fullText, utf8Map) {
+    if (hlList.length === 0) return new Map();
+
+    const nodeToTarget = new Map();
+    textNodes.forEach(node => {
+        let el = node.parentElement;
+        while (el && el.id !== 'highlight-content') {
+            if (targets.includes(el)) {
+                nodeToTarget.set(node, el);
+                break;
+            }
+            el = el.parentElement;
+        }
+    });
+
+    const charToTarget = [];
+    textNodes.forEach(node => {
+        const target = nodeToTarget.get(node);
+        for (const _ of node.textContent) {
+            charToTarget.push(target);
+        }
+    });
+
+    const targetHighlights = new Map();
+    hlList.forEach(hl => {
+        const startChar = getCharIndexFromUTF8Index(fullText, hl.start_offset, utf8Map);
+        const endChar = getCharIndexFromUTF8Index(fullText, hl.end_offset, utf8Map);
+        const midChar = Math.max(0, Math.min(charToTarget.length - 1, Math.floor((startChar + endChar) / 2)));
+        const target = charToTarget[midChar];
+        if (target) {
+            if (!targetHighlights.has(target)) targetHighlights.set(target, []);
+            targetHighlights.get(target).push(hl);
+        }
+    });
+
+    const result = new Map();
+    targetHighlights.forEach((hls, target) => {
+        const sorted = hls.slice().sort((a, b) => a.start_offset - b.start_offset);
+        const laneEnds = [];
+        for (const hl of sorted) {
+            let placed = false;
+            for (let i = 0; i < laneEnds.length; i++) {
+                if (laneEnds[i] <= hl.start_offset) {
+                    laneEnds[i] = hl.end_offset;
+                    placed = true;
+                    break;
+                }
+            }
+            if (!placed) laneEnds.push(hl.end_offset);
+        }
+        result.set(target, laneEnds.length);
+    });
+
+    return result;
+}
+
+function getBlockTargets(container) {
+    const targets = [];
+    const chunksWithBlocks = new Set();
+    const blockSelectors = '.document-chunk p, .document-chunk h1, .document-chunk h2, .document-chunk h3, .document-chunk h4, .document-chunk h5, .document-chunk h6, .document-chunk li, .document-chunk blockquote';
+
+    container.querySelectorAll(blockSelectors).forEach(el => {
+        targets.push(el);
+        const chunk = el.closest('.document-chunk');
+        if (chunk) chunksWithBlocks.add(chunk);
+    });
+
+    container.querySelectorAll('.document-chunk').forEach(chunk => {
+        if (!chunksWithBlocks.has(chunk)) targets.push(chunk);
+    });
+
+    return targets;
+}
+
+function drawHighlights(hlList, container, svg, charMap, fullText, utf8Map) {
+    const startTime = performance.now();
+    const svgNS = "http://www.w3.org/2000/svg";
+    svg.innerHTML = '';
+
+    // If called without pre-computed data, compute it
+    if (!charMap) {
+        const textNodes = collectTextNodes(container);
+        const built = buildCharMap(textNodes);
+        fullText = built.fullText;
+        charMap = built.charMap;
+        utf8Map = buildUTF8ToCharMap(fullText);
+    }
+
+    const containerRect = container.getBoundingClientRect();
+
+    // Batch: create all ranges and read all rects in one pass (single reflow)
+    const hlRanges = [];
+    for (const hl of hlList) {
+        if (hl.start_offset === undefined || hl.end_offset === undefined) continue;
+        const startChar = getCharIndexFromUTF8Index(fullText, hl.start_offset, utf8Map);
+        const endChar = getCharIndexFromUTF8Index(fullText, hl.end_offset, utf8Map);
+        if (startChar >= charMap.length || endChar <= 0 || startChar >= endChar) continue;
+
+        const clampedStart = Math.max(0, startChar);
+        const clampedEnd = Math.min(charMap.length, endChar);
+        const startEntry = charMap[clampedStart];
+        const endEntry = charMap[clampedEnd - 1];
+        if (!startEntry || !endEntry) continue;
+
+        try {
+            const range = document.createRange();
+            range.setStart(startEntry.node, startEntry.offset);
+            range.setEnd(endEntry.node, endEntry.offset + 1);
+            hlRanges.push({ highlight: hl, range });
+        } catch (e) {
+            // skip invalid ranges
+        }
+    }
+
+    // Single reflow: read all client rects
+    const allRects = [];
+    for (const { highlight, range } of hlRanges) {
+        const clientRects = range.getClientRects();
+        const raw = [];
+        for (const r of clientRects) {
+            if (r.width > 0 && r.height > 0) {
+                raw.push({
+                    x: r.left - containerRect.left,
+                    y: r.top - containerRect.top,
+                    width: r.width,
+                    height: r.height
+                });
+            }
+        }
+        const rects = deduplicateRects(raw);
+        for (const rect of rects) {
+            allRects.push({ highlight, rect, stackIndex: 0 });
+        }
+    }
+
+    const lineGroups = new Map();
+    allRects.forEach(item => {
+        const lineIndex = Math.floor(item.rect.y / 25);
+        if (!lineGroups.has(lineIndex)) lineGroups.set(lineIndex, []);
+        lineGroups.get(lineIndex).push(item);
+    });
+
+    lineGroups.forEach(rectsInLine => assignSmartLanes(rectsInLine));
+
+    // Batch DOM writes: build fragment then append once
+    const fragment = document.createDocumentFragment();
+    let lineCount = 0;
+    let gradientCount = 0;
+
+    allRects.forEach(item => {
+        const { highlight, rect, stackIndex } = item;
+        const tags = highlight.tags.map(tagId => findTag(tagId));
+        const colors = tags.map(tag => tag.color);
+        const lineY = rect.y + rect.height + BASE_OFFSET + (stackIndex * (LINE_HEIGHT + LINE_GAP));
+
+        if (colors.length === 1) {
+            const line = createSVGLine(rect.x, lineY, rect.x + rect.width, colors[0], highlight, false);
+            line.setAttribute("opacity", 0.9);
+            fragment.appendChild(line);
+        } else {
+            const group = document.createElementNS(svgNS, "g");
+            const gradientId = `gradient-${lineCount}-${gradientCount++}`;
+            group.appendChild(createSVGGradient(gradientId, colors));
+
+            const line = createSVGLine(rect.x, lineY, rect.x + rect.width, `url(#${gradientId})`, highlight, true);
+            line.setAttribute("opacity", 0.9);
+            group.appendChild(line);
+            fragment.appendChild(group);
+        }
+        lineCount++;
+    });
+
+    svg.appendChild(fragment);
+    svg.setAttribute('height', container.scrollHeight);
+    svg.style.height = container.scrollHeight + 'px';
+    log(`renderHighlights: ${((performance.now() - startTime) / 1000).toFixed(3)}s, ${lineCount} lines`);
+}
+
+function collectTextNodes(container) {
+    const nodes = [];
+    const walker = document.createTreeWalker(container, NodeFilter.SHOW_TEXT, null);
+    let node;
+    while (node = walker.nextNode()) nodes.push(node);
+    return nodes;
+}
+
+function buildCharMap(textNodes) {
+    let fullText = '';
+    const charMap = [];
+    textNodes.forEach(node => {
+        const text = node.textContent;
+        for (let i = 0; i < text.length; i++) {
+            charMap.push({ node, offset: i });
+        }
+        fullText += text;
+    });
+    return { fullText, charMap };
+}
+
+function deduplicateRects(rects) {
+    // Remove exact duplicates
+    const unique = [];
+    for (const r of rects) {
+        const isDupe = unique.some(u =>
+            Math.abs(u.x - r.x) < 1 && Math.abs(u.y - r.y) < 1 &&
+            Math.abs(u.width - r.width) < 1 && Math.abs(u.height - r.height) < 1
+        );
+        if (!isDupe) unique.push(r);
+    }
+
+    // 2. Remove block-level rects (taller than text rects)
+    const medianHeight = unique.length > 0
+        ? unique.map(r => r.height).sort((a, b) => a - b)[Math.floor(unique.length / 2)]
+        : 20;
+    const result = [];
+    for (const r of unique) {
+        if (r.height > medianHeight * 1.3) {
+            const hasOverlapping = unique.some(other => {
+                if (other === r) return false;
+                return Math.abs(r.y - other.y) < r.height &&
+                       other.height <= medianHeight * 1.1;
+            });
+            if (hasOverlapping) continue; // skip this block-level rect
+        }
+        result.push(r);
+    }
+
+    // Merge adjacent rects on the same visual line
+    result.sort((a, b) => a.y - b.y || a.x - b.x);
+    const merged = [];
+    for (const rect of result) {
+        const last = merged[merged.length - 1];
+        if (last && Math.abs(last.y - rect.y) < 3) {
+            const gap = rect.x - (last.x + last.width);
+            if (gap < 2) {
+                last.width = Math.max(last.x + last.width, rect.x + rect.width) - last.x;
+                last.height = Math.max(last.height, rect.height);
+                continue;
+            }
+        }
+        merged.push({ ...rect });
+    }
+    return merged;
+}
+
+function assignSmartLanes(rectsInLine) {
+    const lanes = [];
+    rectsInLine.sort((a, b) => a.rect.x - b.rect.x);
+
+    for (const current of rectsInLine) {
+        let placed = false;
+        for (let laneIdx = 0; laneIdx < lanes.length; laneIdx++) {
+            const overlaps = lanes[laneIdx].some(other => {
+                if (other.highlight.id === current.highlight.id) return false;
+                return !(current.rect.x >= other.rect.x + other.rect.width ||
+                         other.rect.x >= current.rect.x + current.rect.width);
+            });
+            if (!overlaps) {
+                lanes[laneIdx].push(current);
+                current.stackIndex = laneIdx;
+                placed = true;
+                break;
+            }
+        }
+        if (!placed) {
+            current.stackIndex = lanes.length;
+            lanes.push([current]);
+        }
+    }
+    return lanes;
+}
+
+function createSVGLine(x1, y, x2, color, highlight, isGradient) {
+    const svgNS = "http://www.w3.org/2000/svg";
+    const line = document.createElementNS(svgNS, "line");
+
+    line.setAttribute("x1", x1);
+    line.setAttribute("y1", y);
+    line.setAttribute("x2", x2);
+    line.setAttribute("y2", y + (isGradient ? 0.1 : 0));
+    line.setAttribute("stroke", color);
+    line.setAttribute("stroke-width", LINE_HEIGHT);
+    line.setAttribute("stroke-linecap", "round");
+    line.setAttribute("data-highlight-id", highlight.id);
+    line.style.pointerEvents = 'all';
+    line.style.cursor = 'pointer';
+    line.style.transition = 'stroke-width 0.2s';
+
+    line.addEventListener('mouseenter', function(e) {
+        line.setAttribute("stroke-width", "5");
+        showLineTooltip(e, highlight.id);
+    });
+    line.addEventListener('mouseleave', function() {
+        line.setAttribute("stroke-width", LINE_HEIGHT);
+        hideLineTooltip();
+    });
+    line.addEventListener('click', function() {
+        editHighlight.call(line);
+    });
+
+    return line;
+}
+
+function createSVGGradient(id, colors) {
+    const svgNS = "http://www.w3.org/2000/svg";
+    const gradient = document.createElementNS(svgNS, "linearGradient");
+    gradient.setAttribute("id", id);
+    gradient.setAttribute("x1", "0%");
+    gradient.setAttribute("y1", "0%");
+    gradient.setAttribute("x2", "100%");
+    gradient.setAttribute("y2", "0%");
+
+    colors.forEach((color, index) => {
+        const stop = document.createElementNS(svgNS, "stop");
+        stop.setAttribute("offset", colors.length === 1 ? "100%" : `${(index / (colors.length - 1)) * 100}%`);
+        stop.setAttribute("stop-color", color);
+        gradient.appendChild(stop);
+    });
+    return gradient;
+}
+
+function showLineTooltip(event, highlightId) {
+    let tooltip = document.getElementById('highlight-tooltip');
+
+    if (!tooltip) {
+        tooltip = document.createElement('div');
+        tooltip.id = 'highlight-tooltip';
+        document.body.appendChild(tooltip);
+        Object.assign(tooltip.style, {
+            position: 'fixed', padding: '10px', background: '#fff',
+            border: '2px solid #333', borderRadius: '6px',
+            boxShadow: '0 4px 12px rgba(0,0,0,0.2)', fontSize: '13px',
+            pointerEvents: 'none', zIndex: '10000', maxWidth: '300px',
+            wordWrap: 'break-word', overflowWrap: 'break-word'
+        });
+    }
+
+    const hl = highlights[highlightId];
+    if (!hl) return;
+
+    const tags = hl.tags.map(tagId => findTag(tagId));
+    tooltip.innerHTML = `
+        <div style="display: flex; gap: 4px; flex-wrap: wrap; max-width: 280px;">
+            ${tags.map(tag => `
+                <div style="display: inline-block; padding: 4px 8px; border-radius: 3px;
+                    background-color: ${tag.color}; color: white; font-size: 11px;">
+                    ${tag.path || tag.name}
+                </div>
+            `).join('')}
+        </div>
+    `;
+    tooltip.style.display = 'block';
+    tooltip.style.left = (event.clientX + 10) + 'px';
+    tooltip.style.top = (event.clientY + 10) + 'px';
+}
+
+function hideLineTooltip() {
+    const tooltip = document.getElementById('highlight-tooltip');
+    if (tooltip) tooltip.style.display = 'none';
+}

taguette/static/js/login.js

@@ -0,0 +1,15 @@
+$(document).ready(function() {
+    $('#entity_id-select').hierarchySelect({
+        hierarchy: false,
+        search: true,
+        width: 'auto',
+        initialValueSet: true
+    });
+
+    $("#cilogon").click(function(){
+        let entity_id = encodeURIComponent($("#entity_id").val()),
+            url = $(this).attr('href').split('?')[0],
+            url_with_params = `${url}?entity_id=${entity_id}`;
+        $(this).attr('href', url_with_params);
+    });
+})

taguette/static/js/permissions.js

@@ -0,0 +1,153 @@
+/*
+ * Members
+ */
+
+function addMember(login, privileges) {
+    members[login] = {privileges: privileges};
+}
+
+function removeMember(login) {
+    delete members[login];
+}
+
+let members_initial = {};
+let members_displayed = {};
+
+function _memberRow(login, user) {
+    let elem = document.createElement('div');
+    elem.className = 'row members-item';
+    elem.innerHTML = '<div class="col-md-4 text-center">' +
+        '  <i class="fas fa-user fa-2x"></i>' +
+        '  <p class="members-item-login">' + login + '</p>' +
+        '</div>' +
+        '<div class="col-md-4 form-group">' +
+        '  <select class="form-control">' +
+        '    <option value="PROJECT_OWNER">' + gettext("Can create projects") + '</option>' +
+        '    <option value="TEAM_MEMBER">' + gettext("Can't create projects") + '</option>' +
+        '  </select>' +
+        '</div>' +
+        '<hr class="custom-hr" />';
+
+    [].forEach.call(elem.querySelectorAll('option'), function (e) {
+        if (e.value === user.privileges) {
+            e.selected = true;
+        }
+    });
+
+    return elem;
+}
+
+function showMembers() {
+    document.getElementById('members-add').reset();
+    document.getElementById('members-add-fields').removeAttribute('disabled');
+
+    let entries = Object.entries(members);
+    sortByKey(entries, function (e) {
+        return e[0];
+    });
+    log("Members:", entries.map(function (e) {
+        return e[0] + " (" + e[1].privileges + ")";
+    })
+        .join(", "));
+
+    // Empty the list
+    let current_members = document.getElementById('members-current');
+    current_members.innerHTML = '';
+
+    // Fill it back up
+    for (let i = 0; i < entries.length; ++i) {
+        const login = entries[i][0];
+        const user = entries[i][1];
+        const elem = _memberRow(login, user);
+        if(login !== user_login) {
+            current_members.appendChild(elem);
+        }
+    }
+
+    // Store current state so that we can compare later
+    members_initial = Object.assign({}, members);
+    members_displayed = Object.assign({}, members);
+}
+
+document.getElementById('members-add').addEventListener('submit', function (e) {
+    e.preventDefault();
+
+    const login = document.getElementById('member-add-name').value.toLowerCase();
+    if (!login) {
+        return;
+    }
+    const privileges = document.getElementById('member-add-privileges').value;
+
+    // Check login
+    if (login in members_displayed) {
+        showAlert(gettext("Already a member!"));
+        document.getElementById('members-add').reset();
+        return;
+    }
+    postJSON('/api/check_user', {login: login, permission: true})
+        .then(function (result) {
+            if (result.exists) {
+                // Add it at the top
+                const elem = _memberRow(login, {privileges: privileges});
+                const current_members = document.getElementById('members-current');
+                current_members.insertBefore(elem, current_members.firstChild);
+                members_displayed[login] = true;
+
+                document.getElementById('members-add').reset();
+            } else {
+                showAlert(gettext("Cannot add this user<br/>Reasons : <ul><li>User cannot be found</li><li>User is already sponsored</li><li>User role cannot be changed</li></ul>"));
+            }
+        })
+});
+
+function sendMembersPatch() {
+    let patch = {};
+
+    let members_before = Object.assign({}, members_initial);
+
+    const rows = document.getElementById('members-current').querySelectorAll('.members-item');
+    for (let i = 0; i < rows.length; ++i) {
+        const row = rows[i];
+        const login = row.querySelector('.members-item-login').textContent;
+        const privileges = row.querySelector('select').value;
+
+        // Add to patch, if different from stored version
+        if (!members_before[login] || members_before[login].privileges !== privileges) {
+            patch[login] = {privileges: privileges};
+        }
+
+        // Remove from object, so what's left are the removed members
+        delete members_before[login];
+    }
+
+    // Remove the members that are left
+    const entries = Object.entries(members_before);
+    for (let i = 0; i < entries.length; ++i) {
+        patch[entries[i][0]] = null;
+    }
+
+    log("Patching users list");
+    showSpinner();
+    patchJSON('/api/permissions', patch)
+        .then(function () {
+            log("Users list patched");
+        })
+        .catch(function (error) {
+            log("Failed to patch users list", 'error', {error});
+            const updatePermissionsErrorMessage = gettext("Couldn't update permissions!");
+            showAlert(`${updatePermissionsErrorMessage} \n \n`, 'error', {error})
+        })
+        .then(hideSpinner);
+
+    members_initial = {};
+}
+
+document.getElementById('members-submit').addEventListener('click', function (e) {
+    e.preventDefault();
+    sendMembersPatch();
+});
+
+document.getElementById('members-current').addEventListener('submit', function (e) {
+    e.preventDefault();
+    sendMembersPatch();
+});