1210 lines
39 KiB
JavaScript
1210 lines
39 KiB
JavaScript
import {ZipReader, ZipWriter, BlobReader, BlobWriter, TextReader, Uint8ArrayReader, TextWriter, Uint8ArrayWriter} from '@zip.js/zip.js';
|
|
|
|
import {traverse, parseXML, serializeToString, Node} from '../DOMUtils.js'
|
|
import {makeManifestFile, getManifestFileData} from './manifest.js';
|
|
|
|
import 'ses'
|
|
|
|
lockdown();
|
|
|
|
|
|
/** @import {Reader, ZipWriterAddDataOptions} from '@zip.js/zip.js' */
|
|
/** @import {ODFManifest} from './manifest.js' */
|
|
|
|
/** @typedef {ArrayBuffer} ODTFile */
|
|
|
|
const ODTMimetype = 'application/vnd.oasis.opendocument.text'
|
|
|
|
|
|
|
|
|
|
// For a given string, split it into fixed parts and parts to replace
|
|
|
|
/**
|
|
* @typedef TextPlaceToFill
|
|
* @property { {expression: string, replacedString:string}[] } expressions
|
|
* @property {() => void} fill
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
* @param {string} str
|
|
* @param {Compartment} compartment
|
|
* @returns {TextPlaceToFill | undefined}
|
|
*/
|
|
function findPlacesToFillInString(str, compartment) {
|
|
const matches = str.matchAll(/\{([^{#\/]+?)\}/g)
|
|
|
|
/** @type {TextPlaceToFill['expressions']} */
|
|
const expressions = []
|
|
|
|
/** @type {(string | ((data:any) => void))[]} */
|
|
const parts = []
|
|
let remaining = str;
|
|
|
|
for(const match of matches) {
|
|
//console.log('match', match)
|
|
const [matched, group1] = match
|
|
|
|
const replacedString = matched
|
|
const expression = group1.trim()
|
|
expressions.push({expression, replacedString})
|
|
|
|
const [fixedPart, newRemaining] = remaining.split(replacedString, 2)
|
|
|
|
if(fixedPart.length >= 1)
|
|
parts.push(fixedPart)
|
|
|
|
parts.push(() => compartment.evaluate(expression))
|
|
|
|
remaining = newRemaining
|
|
}
|
|
|
|
if(remaining.length >= 1)
|
|
parts.push(remaining)
|
|
|
|
//console.log('parts', parts)
|
|
|
|
|
|
if(remaining === str) {
|
|
// no match found
|
|
return undefined
|
|
}
|
|
else {
|
|
return {
|
|
expressions,
|
|
fill: (data) => {
|
|
return parts.map(p => {
|
|
if(typeof p === 'string')
|
|
return p
|
|
else
|
|
return p(data)
|
|
})
|
|
.join('')
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Content between blockStartNode and blockEndNode is extracted to a documentFragment
|
|
* The original document is modified because nodes are removed from it to be part of the returned documentFragment
|
|
*
|
|
* startChild and endChild are ancestors of, respectively, blockStartNode and blockEndNode
|
|
* and startChild.parentNode === endChild.parentNode
|
|
*
|
|
* @precondition blockStartNode needs to be before blockEndNode in document order
|
|
*
|
|
* @param {Node} blockStartNode
|
|
* @param {Node} blockEndNode
|
|
* @returns {{startChild: Node, endChild:Node, content: DocumentFragment}}
|
|
*/
|
|
function extractBlockContent(blockStartNode, blockEndNode) {
|
|
// find common ancestor of blockStartNode and blockEndNode
|
|
let commonAncestor
|
|
|
|
let startAncestor = blockStartNode
|
|
let endAncestor = blockEndNode
|
|
|
|
const startAncestry = new Set([startAncestor])
|
|
const endAncestry = new Set([endAncestor])
|
|
|
|
while(!startAncestry.has(endAncestor) && !endAncestry.has(startAncestor)) {
|
|
if(startAncestor.parentNode) {
|
|
startAncestor = startAncestor.parentNode
|
|
startAncestry.add(startAncestor)
|
|
}
|
|
if(endAncestor.parentNode) {
|
|
endAncestor = endAncestor.parentNode
|
|
endAncestry.add(endAncestor)
|
|
}
|
|
}
|
|
|
|
if(startAncestry.has(endAncestor)) {
|
|
commonAncestor = endAncestor
|
|
}
|
|
else {
|
|
commonAncestor = startAncestor
|
|
}
|
|
|
|
const startAncestryToCommonAncestor = [...startAncestry].slice(0, [...startAncestry].indexOf(commonAncestor))
|
|
const endAncestryToCommonAncestor = [...endAncestry].slice(0, [...endAncestry].indexOf(commonAncestor))
|
|
|
|
const startChild = startAncestryToCommonAncestor.at(-1)
|
|
const endChild = endAncestryToCommonAncestor.at(-1)
|
|
|
|
// Extract DOM content in a documentFragment
|
|
const contentFragment = blockStartNode.ownerDocument.createDocumentFragment()
|
|
|
|
/** @type {Element[]} */
|
|
const repeatedPatternArray = []
|
|
let sibling = startChild.nextSibling
|
|
|
|
while(sibling !== endChild) {
|
|
repeatedPatternArray.push(sibling)
|
|
sibling = sibling.nextSibling;
|
|
}
|
|
|
|
for(const sibling of repeatedPatternArray) {
|
|
sibling.parentNode?.removeChild(sibling)
|
|
contentFragment.appendChild(sibling)
|
|
}
|
|
|
|
return {
|
|
startChild,
|
|
endChild,
|
|
content: contentFragment
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
*
|
|
* @param {Node} ifOpeningMarkerNode
|
|
* @param {Node | undefined} ifElseMarkerNode
|
|
* @param {Node} ifClosingMarkerNode
|
|
* @param {string} ifBlockConditionExpression
|
|
* @param {Compartment} compartment
|
|
*/
|
|
function fillIfBlock(ifOpeningMarkerNode, ifElseMarkerNode, ifClosingMarkerNode, ifBlockConditionExpression, compartment) {
|
|
const conditionValue = compartment.evaluate(ifBlockConditionExpression)
|
|
|
|
let startChild
|
|
let endChild
|
|
|
|
let markerNodes = new Set()
|
|
|
|
let chosenFragment
|
|
|
|
if(ifElseMarkerNode) {
|
|
const {
|
|
startChild: startIfThenChild,
|
|
endChild: endIfThenChild,
|
|
content: thenFragment
|
|
} = extractBlockContent(ifOpeningMarkerNode, ifElseMarkerNode)
|
|
|
|
const {
|
|
startChild: startIfElseChild,
|
|
endChild: endIfElseChild,
|
|
content: elseFragment
|
|
} = extractBlockContent(ifElseMarkerNode, ifClosingMarkerNode)
|
|
|
|
chosenFragment = conditionValue ? thenFragment : elseFragment
|
|
startChild = startIfThenChild
|
|
endChild = endIfElseChild
|
|
|
|
markerNodes
|
|
.add(startIfThenChild).add(endIfThenChild)
|
|
.add(startIfElseChild).add(endIfElseChild)
|
|
}
|
|
else {
|
|
const {
|
|
startChild: startIfThenChild,
|
|
endChild: endIfThenChild,
|
|
content: thenFragment
|
|
} = extractBlockContent(ifOpeningMarkerNode, ifClosingMarkerNode)
|
|
|
|
chosenFragment = conditionValue ? thenFragment : undefined
|
|
startChild = startIfThenChild
|
|
endChild = endIfThenChild
|
|
|
|
markerNodes
|
|
.add(startIfThenChild).add(endIfThenChild)
|
|
}
|
|
|
|
|
|
if(chosenFragment) {
|
|
fillTemplatedOdtElement(
|
|
chosenFragment,
|
|
compartment
|
|
)
|
|
|
|
endChild.parentNode.insertBefore(chosenFragment, endChild)
|
|
}
|
|
|
|
for(const markerNode of markerNodes) {
|
|
try {
|
|
// may throw if node already out of tree
|
|
// might happen if
|
|
markerNode.parentNode.removeChild(markerNode)
|
|
}
|
|
catch(e) {}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
* @param {Node} startNode
|
|
* @param {string} iterableExpression
|
|
* @param {string} itemExpression
|
|
* @param {Node} endNode
|
|
* @param {Compartment} compartment
|
|
*/
|
|
function fillEachBlock(startNode, iterableExpression, itemExpression, endNode, compartment) {
|
|
//console.log('fillEachBlock', iterableExpression, itemExpression)
|
|
//console.log('startNode', startNode.nodeType, startNode.nodeName)
|
|
//console.log('endNode', endNode.nodeType, endNode.nodeName)
|
|
|
|
const {startChild, endChild, content: repeatedFragment} = extractBlockContent(startNode, endNode)
|
|
|
|
// Find the iterable in the data
|
|
// PPP eventually, evaluate the expression as a JS expression
|
|
let iterable = compartment.evaluate(iterableExpression)
|
|
if(!iterable || typeof iterable[Symbol.iterator] !== 'function') {
|
|
// when there is no iterable, silently replace with empty array
|
|
iterable = []
|
|
}
|
|
|
|
// create each loop result
|
|
// using a for-of loop to accept all iterable values
|
|
for(const item of iterable) {
|
|
/** @type {DocumentFragment} */
|
|
// @ts-ignore
|
|
const itemFragment = repeatedFragment.cloneNode(true)
|
|
|
|
let insideCompartment = new Compartment({
|
|
globals: Object.assign({}, compartment.globalThis, {[itemExpression]: item}),
|
|
__options__: true
|
|
})
|
|
|
|
// recursive call to fillTemplatedOdtElement on itemFragment
|
|
fillTemplatedOdtElement(
|
|
itemFragment,
|
|
insideCompartment
|
|
)
|
|
|
|
endChild.parentNode.insertBefore(itemFragment, endChild)
|
|
}
|
|
|
|
// remove block marker elements
|
|
startChild.parentNode.removeChild(startChild)
|
|
endChild.parentNode.removeChild(endChild)
|
|
}
|
|
|
|
|
|
const IF = 'IF'
|
|
const EACH = 'EACH'
|
|
|
|
// the regexps below are shared, so they shoudn't have state (no 'g' flag)
|
|
const ifStartMarkerRegex = /{#if\s+([^}]+?)\s*}/;
|
|
const elseMarker = '{:else}'
|
|
const closingIfMarker = '{/if}'
|
|
|
|
const eachStartMarkerRegex = /{#each\s+([^}]+?)\s+as\s+([^}]+?)\s*}/;
|
|
const eachClosingMarker = '{/each}'
|
|
|
|
|
|
|
|
/**
|
|
*
|
|
* @param {Element | DocumentFragment | Document} rootElement
|
|
* @param {Compartment} compartment
|
|
* @returns {void}
|
|
*/
|
|
function fillTemplatedOdtElement(rootElement, compartment) {
|
|
//console.log('fillTemplatedOdtElement', rootElement.nodeType, rootElement.nodeName)
|
|
|
|
let currentlyOpenBlocks = []
|
|
|
|
/** @type {Node | undefined} */
|
|
let eachOpeningMarkerNode
|
|
/** @type {Node | undefined} */
|
|
let eachClosingMarkerNode
|
|
|
|
let eachBlockIterableExpression, eachBlockItemExpression;
|
|
|
|
|
|
/** @type {Node | undefined} */
|
|
let ifOpeningMarkerNode
|
|
/** @type {Node | undefined} */
|
|
let ifElseMarkerNode
|
|
/** @type {Node | undefined} */
|
|
let ifClosingMarkerNode
|
|
|
|
let ifBlockConditionExpression
|
|
// Traverse "in document order"
|
|
|
|
// @ts-ignore
|
|
traverse(rootElement, currentNode => {
|
|
//console.log('currentlyUnclosedBlocks', currentlyUnclosedBlocks)
|
|
const insideAnOpenBlock = currentlyOpenBlocks.length >= 1
|
|
|
|
if(currentNode.nodeType === Node.TEXT_NODE) {
|
|
const text = currentNode.textContent || ''
|
|
|
|
/**
|
|
* looking for {#each x as y}
|
|
*/
|
|
const eachStartMatch = text.match(eachStartMarkerRegex);
|
|
|
|
if(eachStartMatch) {
|
|
//console.log('startMatch', startMatch)
|
|
|
|
currentlyOpenBlocks.push(EACH)
|
|
|
|
if(insideAnOpenBlock) {
|
|
// do nothing
|
|
}
|
|
else {
|
|
let [_, _iterableExpression, _itemExpression] = eachStartMatch
|
|
|
|
eachBlockIterableExpression = _iterableExpression
|
|
eachBlockItemExpression = _itemExpression
|
|
eachOpeningMarkerNode = currentNode
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Looking for {/each}
|
|
*/
|
|
const isEachClosingBlock = text.includes(eachClosingMarker)
|
|
|
|
if(isEachClosingBlock) {
|
|
|
|
//console.log('isEachClosingBlock', isEachClosingBlock)
|
|
|
|
if(!eachOpeningMarkerNode)
|
|
throw new Error(`{/each} found without corresponding opening {#each x as y}`)
|
|
|
|
if(currentlyOpenBlocks.at(-1) !== EACH)
|
|
throw new Error(`{/each} found while the last opened block was not an opening {#each x as y}`)
|
|
|
|
if(currentlyOpenBlocks.length === 1) {
|
|
eachClosingMarkerNode = currentNode
|
|
|
|
// found an {#each} and its corresponding {/each}
|
|
// execute replacement loop
|
|
fillEachBlock(eachOpeningMarkerNode, eachBlockIterableExpression, eachBlockItemExpression, eachClosingMarkerNode, compartment)
|
|
|
|
eachOpeningMarkerNode = undefined
|
|
eachBlockIterableExpression = undefined
|
|
eachBlockItemExpression = undefined
|
|
eachClosingMarkerNode = undefined
|
|
}
|
|
else {
|
|
// ignore because it will be treated as part of the outer {#each}
|
|
}
|
|
|
|
currentlyOpenBlocks.pop()
|
|
}
|
|
|
|
|
|
/**
|
|
* Looking for {#if ...}
|
|
*/
|
|
const ifStartMatch = text.match(ifStartMarkerRegex);
|
|
|
|
if(ifStartMatch) {
|
|
currentlyOpenBlocks.push(IF)
|
|
|
|
if(insideAnOpenBlock) {
|
|
// do nothing because the marker is too deep
|
|
}
|
|
else {
|
|
let [_, _ifBlockConditionExpression] = ifStartMatch
|
|
|
|
ifBlockConditionExpression = _ifBlockConditionExpression
|
|
ifOpeningMarkerNode = currentNode
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Looking for {:else}
|
|
*/
|
|
const hasElseMarker = text.includes(elseMarker);
|
|
|
|
if(hasElseMarker) {
|
|
if(!insideAnOpenBlock)
|
|
throw new Error('{:else} without a corresponding {#if}')
|
|
|
|
if(currentlyOpenBlocks.length === 1) {
|
|
if(currentlyOpenBlocks[0] === IF) {
|
|
ifElseMarkerNode = currentNode
|
|
}
|
|
else
|
|
throw new Error('{:else} inside an {#each} but without a corresponding {#if}')
|
|
}
|
|
else {
|
|
// do nothing because the marker is too deep
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Looking for {/if}
|
|
*/
|
|
const hasClosingMarker = text.includes(closingIfMarker);
|
|
|
|
if(hasClosingMarker) {
|
|
if(!insideAnOpenBlock)
|
|
throw new Error('{/if} without a corresponding {#if}')
|
|
|
|
if(currentlyOpenBlocks.length === 1) {
|
|
if(currentlyOpenBlocks[0] === IF) {
|
|
ifClosingMarkerNode = currentNode
|
|
|
|
// found an {#if} and its corresponding {/if}
|
|
// execute replacement loop
|
|
fillIfBlock(ifOpeningMarkerNode, ifElseMarkerNode, ifClosingMarkerNode, ifBlockConditionExpression, compartment)
|
|
|
|
ifOpeningMarkerNode = undefined
|
|
ifElseMarkerNode = undefined
|
|
ifClosingMarkerNode = undefined
|
|
ifBlockConditionExpression = undefined
|
|
}
|
|
else
|
|
throw new Error('{/if} inside an {#each} but without a corresponding {#if}')
|
|
}
|
|
else {
|
|
// do nothing because the marker is too deep
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Looking for variables for substitutions
|
|
*/
|
|
if(!insideAnOpenBlock) {
|
|
// @ts-ignore
|
|
if(currentNode.data) {
|
|
// @ts-ignore
|
|
const placesToFill = findPlacesToFillInString(currentNode.data, compartment)
|
|
|
|
if(placesToFill) {
|
|
const newText = placesToFill.fill()
|
|
// @ts-ignore
|
|
const newTextNode = currentNode.ownerDocument?.createTextNode(newText)
|
|
// @ts-ignore
|
|
currentNode.parentNode?.replaceChild(newTextNode, currentNode)
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// ignore because it will be treated as part of the outer {#each} block
|
|
}
|
|
}
|
|
|
|
if(currentNode.nodeType === Node.ATTRIBUTE_NODE) {
|
|
// Looking for variables for substitutions
|
|
if(!insideAnOpenBlock) {
|
|
// @ts-ignore
|
|
if(currentNode.value) {
|
|
// @ts-ignore
|
|
const placesToFill = findPlacesToFillInString(currentNode.value, compartment)
|
|
if(placesToFill) {
|
|
// @ts-ignore
|
|
currentNode.value = placesToFill.fill()
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// ignore because it will be treated as part of the {#each} block
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
|
|
// Helper function to find all regex matches with positions
|
|
/**
|
|
*
|
|
* @param {string} text
|
|
* @param {string | RegExp} pattern
|
|
* @returns {{marker: string, index: number}[]}
|
|
*/
|
|
function findAllMatches(text, pattern) {
|
|
const results = [];
|
|
let match;
|
|
|
|
if(typeof pattern === 'string') {
|
|
// For string markers like elseMarker and closingIfMarker
|
|
let index = 0;
|
|
while((index = text.indexOf(pattern, index)) !== -1) {
|
|
results.push({
|
|
marker: pattern,
|
|
index: index
|
|
});
|
|
index += pattern.length;
|
|
}
|
|
} else {
|
|
// For regex patterns
|
|
pattern = new RegExp(pattern.source, 'g');
|
|
while((match = pattern.exec(text)) !== null) {
|
|
results.push({
|
|
marker: match[0],
|
|
index: match.index
|
|
});
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
* @param {Node} node1
|
|
* @param {Node} node2
|
|
* @returns {Node}
|
|
*/
|
|
function findCommonAncestor(node1, node2) {
|
|
const ancestors1 = getAncestors(node1);
|
|
const ancestors2 = getAncestors(node2);
|
|
|
|
for(const ancestor of ancestors1) {
|
|
if(ancestors2.includes(ancestor)) {
|
|
return ancestor;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param {Node} node
|
|
* @returns {Node[]}
|
|
*/
|
|
function getAncestors(node) {
|
|
const ancestors = [];
|
|
let current = node;
|
|
|
|
while(current) {
|
|
ancestors.push(current);
|
|
current = current.parentNode;
|
|
}
|
|
|
|
return ancestors;
|
|
}
|
|
|
|
// Helper function to find nodes between start and end (inclusive)
|
|
function findNodesBetween(startNode, endNode) {
|
|
const commonAncestor = findCommonAncestor(startNode, endNode);
|
|
if(!commonAncestor) return [];
|
|
|
|
const result = [];
|
|
let capturing = false;
|
|
|
|
function traverse(node) {
|
|
if(node === startNode) {
|
|
capturing = true;
|
|
}
|
|
|
|
if(capturing) {
|
|
result.push(node);
|
|
}
|
|
|
|
if(node === endNode) {
|
|
capturing = false;
|
|
return true;
|
|
}
|
|
|
|
for(let child = node.firstChild; child; child = child.nextSibling) {
|
|
if(traverse(child)) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
traverse(commonAncestor);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* text position of a node relative to a text nodes within a container
|
|
*
|
|
* @param {Text} node
|
|
* @param {Text[]} containerTextNodes
|
|
* @returns {number}
|
|
*/
|
|
function getNodeTextPosition(node, containerTextNodes) {
|
|
let position = 0;
|
|
|
|
for(const currentTextNode of containerTextNodes) {
|
|
if(currentTextNode === node) {
|
|
return position
|
|
}
|
|
else {
|
|
position += (currentTextNode.textContent || '').length;
|
|
}
|
|
}
|
|
|
|
throw new Error(`[${getNodeTextPosition.name}] None of containerTextNodes elements is equal to node`)
|
|
}
|
|
|
|
|
|
/** @typedef {Node[]} DOMPath */
|
|
|
|
/**
|
|
* get the path from ancestor to descendant
|
|
*
|
|
* @param {Node} node
|
|
* @param {Node} ancestor
|
|
* @returns {DOMPath}
|
|
*/
|
|
function getPathToNode(node, ancestor) {
|
|
/** @type {DOMPath} */
|
|
const path = [];
|
|
let current = node;
|
|
|
|
while(current && current !== ancestor) {
|
|
path.unshift(current);
|
|
current = current.parentNode;
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
/**
|
|
* find the point where two paths diverge
|
|
*
|
|
* @param {DOMPath} path1
|
|
* @param {DOMPath} path2
|
|
* @returns {Node | undefined}
|
|
*/
|
|
function findDivergingPoint(path1, path2) {
|
|
for(let i = 0; i < Math.min(path1.length, path2.length); i++) {
|
|
if(path1[i] !== path2[i]) {
|
|
return path1[i - 1] || undefined; // Return the last common node
|
|
}
|
|
}
|
|
|
|
// One path is a prefix of the other
|
|
return path1[Math.min(path1.length, path2.length) - 1];
|
|
}
|
|
|
|
/**
|
|
* handle the case where start and end nodes have a direct relationship
|
|
* @param {Text} startNode
|
|
* @param {Text} endNode
|
|
* @param {number} posInStartNode
|
|
* @param {number} posInEndNode
|
|
* @param {string} markerText
|
|
*/
|
|
function consolidateDirectRelationship(startNode, endNode, posInStartNode, posInEndNode, markerText) {
|
|
const startNodeParent = startNode.parentNode;
|
|
const endNodeParent = endNode.parentNode;
|
|
const document = startNode.ownerDocument;
|
|
|
|
console.log('consolidateDirectRelationship - startNodeParent === endNodeParent', startNodeParent === endNodeParent)
|
|
|
|
if(startNodeParent === endNodeParent) {
|
|
// Siblings case
|
|
let currentNode = startNode;
|
|
let nextSibling;
|
|
|
|
// Handle start node - split if needed to preserve text before marker
|
|
if(posInStartNode > 0) {
|
|
console.log('posInStartNode > 0', posInStartNode)
|
|
console.log('startNode', startNode.textContent)
|
|
// Split text node to preserve text before marker
|
|
const remainingNode = startNode.splitText(posInStartNode);
|
|
currentNode = remainingNode.previousSibling; // Now we'll work with the second part
|
|
remainingNode.parentNode?.removeChild(remainingNode)
|
|
console.log('remainingNode', remainingNode.textContent)
|
|
}
|
|
|
|
// Create marker node
|
|
const markerNode = document.createTextNode(markerText);
|
|
|
|
// Insert marker after current node
|
|
if(currentNode.nextSibling) {
|
|
startNodeParent.insertBefore(markerNode, currentNode.nextSibling);
|
|
} else {
|
|
startNodeParent.appendChild(markerNode);
|
|
}
|
|
|
|
// Remove nodes between start split and end node
|
|
currentNode = markerNode.nextSibling;
|
|
while(currentNode && currentNode !== endNode) {
|
|
nextSibling = currentNode.nextSibling;
|
|
startNodeParent.removeChild(currentNode);
|
|
currentNode = nextSibling;
|
|
}
|
|
|
|
// Handle end node - split if needed to preserve text after marker
|
|
if(posInEndNode < endNode.textContent.length) {
|
|
// Split to keep text after marker
|
|
endNode.splitText(posInEndNode);
|
|
// First part (up to the split point) should be removed
|
|
startNodeParent.removeChild(endNode);
|
|
} else {
|
|
// No text after marker, remove the entire end node
|
|
startNodeParent.removeChild(endNode);
|
|
}
|
|
} else {
|
|
// Handle nested case (one is ancestor of other)
|
|
// This is more complex and needs customized handling
|
|
// Simplified approach: replace everything with marker
|
|
// A more sophisticated approach would be needed for production
|
|
|
|
const isStartAncestorOfEnd = isAncestor(startNode, endNode);
|
|
if(isStartAncestorOfEnd) {
|
|
replaceWithMarker(startNode, markerText);
|
|
} else {
|
|
replaceWithMarker(endNode, markerText);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Helper function to check if one node is ancestor of another
|
|
function isAncestor(potentialAncestor, node) {
|
|
let current = node.parentNode;
|
|
while(current) {
|
|
if(current === potentialAncestor) return true;
|
|
current = current.parentNode;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Helper function to replace a node with marker text
|
|
function replaceWithMarker(node, markerText) {
|
|
const document = node.ownerDocument;
|
|
const markerNode = document.createTextNode(markerText);
|
|
node.parentNode.replaceChild(markerNode, node);
|
|
}
|
|
|
|
// Helper function to remove nodes between two sibling branches
|
|
function removeNodesBetween(startBranch, endBranch, commonAncestor) {
|
|
let removing = false;
|
|
let nodesToRemove = [];
|
|
|
|
for(let child = commonAncestor.firstChild; child; child = child.nextSibling) {
|
|
if(child === startBranch) {
|
|
removing = true;
|
|
continue; // Don't remove the start branch
|
|
}
|
|
|
|
if(removing) {
|
|
if(child === endBranch) {
|
|
break; // Stop when we reach end branch
|
|
}
|
|
nodesToRemove.push(child);
|
|
}
|
|
}
|
|
|
|
// Remove all nodes marked for removal
|
|
for(const nodeToRemove of nodesToRemove) {
|
|
commonAncestor.removeChild(nodeToRemove);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
* @param {Document} document
|
|
* @param {Compartment} compartment
|
|
* @returns {void}
|
|
*/
|
|
function fillTemplatedOdtDocument(document, compartment) {
|
|
|
|
// Prepare tree to be used as template
|
|
// Perform a first pass to detect templating markers with formatting to remove it
|
|
const potentialMarkerContainers = [
|
|
...Array.from(document.getElementsByTagName('text:p')),
|
|
...Array.from(document.getElementsByTagName('text:h'))
|
|
]
|
|
|
|
for(const potentialMarkerContainer of potentialMarkerContainers) {
|
|
// Check if any template marker is split across multiple text nodes
|
|
// Get all text nodes within this container
|
|
/** @type {Text[]} */
|
|
const containerTextNodesInTreeOrder = [];
|
|
let fullText = ''
|
|
traverse(potentialMarkerContainer, node => {
|
|
if(node.nodeType === Node.TEXT_NODE) {
|
|
containerTextNodesInTreeOrder.push(/** @type {Text} */(node))
|
|
fullText = fullText + node.textContent
|
|
}
|
|
})
|
|
|
|
// Check for each template marker
|
|
const positionedMarkers = [
|
|
...findAllMatches(fullText, ifStartMarkerRegex),
|
|
...findAllMatches(fullText, elseMarker),
|
|
...findAllMatches(fullText, closingIfMarker),
|
|
...findAllMatches(fullText, eachStartMarkerRegex),
|
|
...findAllMatches(fullText, eachClosingMarker)
|
|
];
|
|
|
|
console.log('positionedMarkers', positionedMarkers)
|
|
|
|
// If no markers found, skip this container
|
|
if(positionedMarkers.length >= 1) {
|
|
|
|
// For each marker, check if it's contained within a single text node
|
|
for(const positionedMarker of positionedMarkers) {
|
|
console.log('positionedMarker', positionedMarker)
|
|
|
|
let markerStart = -1;
|
|
let markerEnd = -1;
|
|
let currentPos = 0;
|
|
let markerSpansNodes = false;
|
|
let startNode = null;
|
|
let endNode = null;
|
|
|
|
// Find which text node(s) contain this marker
|
|
for(const textNode of containerTextNodesInTreeOrder) {
|
|
const nodeStart = currentPos;
|
|
const nodeEnd = nodeStart + textNode.textContent.length;
|
|
|
|
// If start of marker is in this node
|
|
if(markerStart === -1 && positionedMarker.index >= nodeStart && positionedMarker.index < nodeEnd) {
|
|
markerStart = positionedMarker.index;
|
|
startNode = textNode;
|
|
}
|
|
|
|
// If end of marker is in this node
|
|
if(markerStart !== -1 && positionedMarker.index + positionedMarker.marker.length > nodeStart &&
|
|
positionedMarker.index + positionedMarker.marker.length <= nodeEnd) {
|
|
markerEnd = positionedMarker.index + positionedMarker.marker.length;
|
|
endNode = textNode;
|
|
break;
|
|
}
|
|
|
|
currentPos = nodeEnd;
|
|
}
|
|
|
|
// Check if marker spans multiple nodes
|
|
if(startNode !== endNode) {
|
|
console.log('startNode !== endNode')
|
|
const commonAncestor = findCommonAncestor(startNode, endNode);
|
|
|
|
// Calculate relative positions within the nodes
|
|
let startNodeTextContent = startNode.textContent || '';
|
|
let endNodeTextContent = endNode.textContent || '';
|
|
|
|
// Calculate the position within the start node
|
|
let posInStartNode = positionedMarker.index - getNodeTextPosition(startNode, containerTextNodesInTreeOrder);
|
|
|
|
// Calculate the position within the end node
|
|
let posInEndNode = (positionedMarker.index + positionedMarker.marker.length) - getNodeTextPosition(endNode, containerTextNodesInTreeOrder);
|
|
|
|
// Get the path from common ancestor to start and end nodes
|
|
const pathToStart = getPathToNode(startNode, commonAncestor);
|
|
const pathToEnd = getPathToNode(endNode, commonAncestor);
|
|
|
|
// Find the diverging point in the paths
|
|
const lowestCommonAncestorChild = findDivergingPoint(pathToStart, pathToEnd);
|
|
|
|
console.log('lowestCommonAncestorChild', lowestCommonAncestorChild)
|
|
|
|
if(!lowestCommonAncestorChild) {
|
|
// Direct parent-child relationship or other simple case
|
|
// Handle separately
|
|
consolidateDirectRelationship(startNode, endNode, posInStartNode, posInEndNode, positionedMarker.marker);
|
|
} else {
|
|
// Complex case: we need to:
|
|
// 1. Preserve text before marker in startNode
|
|
// 2. Preserve text after marker in endNode
|
|
// 3. Replace everything in-between with marker text
|
|
|
|
// Get all nodes between the diverging branches (including the branches)
|
|
const startBranch = pathToStart[pathToStart.indexOf(lowestCommonAncestorChild)];
|
|
const endBranch = pathToEnd[pathToEnd.indexOf(lowestCommonAncestorChild)];
|
|
|
|
// First, handle the start node - split if necessary
|
|
if(posInStartNode > 0) {
|
|
// Text exists before the marker - preserve it
|
|
const textBeforeMarker = startNodeTextContent.substring(0, posInStartNode);
|
|
const parentOfStartNode = startNode.parentNode;
|
|
|
|
// Replace the start node with the text before marker
|
|
startNode.textContent = textBeforeMarker;
|
|
|
|
// Create a new node for the start of the marker
|
|
const startOfMarkerNode = document.createTextNode(positionedMarker.marker);
|
|
|
|
// Insert after the modified start node
|
|
if(startNode.nextSibling) {
|
|
parentOfStartNode.insertBefore(startOfMarkerNode, startNode.nextSibling);
|
|
} else {
|
|
parentOfStartNode.appendChild(startOfMarkerNode);
|
|
}
|
|
} else {
|
|
// No text before marker, just replace the content
|
|
startNode.textContent = positionedMarker.marker;
|
|
}
|
|
|
|
// Handle the end node - split if necessary
|
|
if(posInEndNode < endNodeTextContent.length) {
|
|
// Text exists after the marker - preserve it
|
|
const textAfterMarker = endNodeTextContent.substring(posInEndNode);
|
|
const parentOfEndNode = endNode.parentNode;
|
|
|
|
// Replace the end node with just the text after marker
|
|
endNode.textContent = textAfterMarker;
|
|
|
|
// Create a new node for the end of the marker if needed
|
|
// Only needed if we haven't already added the full marker to the start node
|
|
if(posInStartNode > 0) {
|
|
const endOfMarkerNode = document.createTextNode(""); // Empty as marker is in start node
|
|
|
|
// Insert before the modified end node
|
|
parentOfEndNode.insertBefore(endOfMarkerNode, endNode);
|
|
}
|
|
} else {
|
|
// No text after marker
|
|
if(posInStartNode > 0) {
|
|
// If we preserved text before the marker, remove the end node
|
|
// as the marker is now fully in the start branch
|
|
endNode.parentNode.removeChild(endNode);
|
|
} else {
|
|
// Otherwise just replace the content
|
|
endNode.textContent = "";
|
|
}
|
|
}
|
|
|
|
// Now remove all nodes between start branch and end branch
|
|
// but not the branches themselves
|
|
removeNodesBetween(startBranch, endBranch, commonAncestor);
|
|
}
|
|
|
|
// After consolidation, we can break as the DOM structure has changed
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Perform a second pass to split textnodes when they contain several block markers
|
|
traverse(document, currentNode => {
|
|
if(currentNode.nodeType === Node.TEXT_NODE) {
|
|
// find all marker starts and ends and split textNode
|
|
let remainingText = currentNode.textContent || ''
|
|
|
|
while(remainingText.length >= 1) {
|
|
let matchText;
|
|
let matchIndex;
|
|
|
|
// looking for a block marker
|
|
for(const marker of [ifStartMarkerRegex, elseMarker, closingIfMarker, eachStartMarkerRegex, eachClosingMarker]) {
|
|
if(typeof marker === 'string') {
|
|
const index = remainingText.indexOf(marker)
|
|
|
|
if(index !== -1) {
|
|
matchText = marker
|
|
matchIndex = index
|
|
|
|
// found the first match
|
|
break; // get out of loop
|
|
}
|
|
}
|
|
else {
|
|
// marker is a RegExp
|
|
const match = remainingText.match(marker)
|
|
|
|
if(match) {
|
|
matchText = match[0]
|
|
matchIndex = match.index
|
|
|
|
// found the first match
|
|
break; // get out of loop
|
|
}
|
|
}
|
|
}
|
|
|
|
if(matchText) {
|
|
// split 3-way : before-match, match and after-match
|
|
|
|
if(matchText.length < remainingText.length) {
|
|
// @ts-ignore
|
|
let afterMatchTextNode = currentNode.splitText(matchIndex + matchText.length)
|
|
if(afterMatchTextNode.textContent && afterMatchTextNode.textContent.length >= 1) {
|
|
remainingText = afterMatchTextNode.textContent
|
|
}
|
|
else {
|
|
remainingText = ''
|
|
}
|
|
|
|
// per spec, currentNode now contains before-match and match text
|
|
|
|
// @ts-ignore
|
|
if(matchIndex > 0) {
|
|
// @ts-ignore
|
|
currentNode.splitText(matchIndex)
|
|
}
|
|
|
|
if(afterMatchTextNode) {
|
|
currentNode = afterMatchTextNode
|
|
}
|
|
}
|
|
else {
|
|
remainingText = ''
|
|
}
|
|
}
|
|
else {
|
|
remainingText = ''
|
|
}
|
|
}
|
|
|
|
}
|
|
else {
|
|
// skip
|
|
}
|
|
})
|
|
|
|
// now, each Node contains at most one block marker
|
|
|
|
fillTemplatedOdtElement(document, compartment)
|
|
}
|
|
|
|
|
|
|
|
const keptFiles = new Set(['content.xml', 'styles.xml', 'mimetype', 'META-INF/manifest.xml'])
|
|
|
|
/**
|
|
*
|
|
* @param {string} filename
|
|
* @returns {boolean}
|
|
*/
|
|
function keepFile(filename) {
|
|
return keptFiles.has(filename) || filename.startsWith('Pictures/')
|
|
}
|
|
|
|
|
|
/**
|
|
* @param {ODTFile} odtTemplate
|
|
* @param {any} data
|
|
* @returns {Promise<ODTFile>}
|
|
*/
|
|
export default async function fillOdtTemplate(odtTemplate, data) {
|
|
|
|
const reader = new ZipReader(new Uint8ArrayReader(new Uint8Array(odtTemplate)));
|
|
|
|
// Lire toutes les entrées du fichier ODT
|
|
const entries = reader.getEntriesGenerator();
|
|
|
|
// Créer un ZipWriter pour le nouveau fichier ODT
|
|
const writer = new ZipWriter(new Uint8ArrayWriter());
|
|
|
|
/** @type {ODFManifest} */
|
|
let manifestFileData;
|
|
|
|
/** @type {{filename: string, content: Reader, options?: ZipWriterAddDataOptions}[]} */
|
|
const zipEntriesToAdd = []
|
|
|
|
// Parcourir chaque entrée du fichier ODT
|
|
for await(const entry of entries) {
|
|
const filename = entry.filename
|
|
|
|
//console.log('entry', filename, entry.directory)
|
|
|
|
// remove other files
|
|
if(!keepFile(filename)) {
|
|
// ignore, do not create a corresponding entry in the new zip
|
|
}
|
|
else {
|
|
let content
|
|
let options
|
|
|
|
switch(filename) {
|
|
case 'mimetype':
|
|
content = new TextReader(ODTMimetype)
|
|
options = {
|
|
level: 0,
|
|
compressionMethod: 0,
|
|
dataDescriptor: false,
|
|
extendedTimestamp: false,
|
|
}
|
|
|
|
zipEntriesToAdd.push({filename, content, options})
|
|
|
|
break;
|
|
case 'content.xml':
|
|
// @ts-ignore
|
|
const contentXml = await entry.getData(new TextWriter());
|
|
const contentDocument = parseXML(contentXml);
|
|
|
|
const compartment = new Compartment({
|
|
globals: data,
|
|
__options__: true
|
|
})
|
|
|
|
fillTemplatedOdtDocument(contentDocument, compartment)
|
|
|
|
const updatedContentXml = serializeToString(contentDocument)
|
|
|
|
content = new TextReader(updatedContentXml)
|
|
options = {
|
|
lastModDate: entry.lastModDate,
|
|
level: 9
|
|
};
|
|
|
|
zipEntriesToAdd.push({filename, content, options})
|
|
|
|
break;
|
|
|
|
case 'META-INF/manifest.xml':
|
|
// @ts-ignore
|
|
const manifestXml = await entry.getData(new TextWriter());
|
|
const manifestDocument = parseXML(manifestXml);
|
|
manifestFileData = getManifestFileData(manifestDocument)
|
|
|
|
break;
|
|
|
|
case 'styles.xml':
|
|
default:
|
|
const blobWriter = new BlobWriter();
|
|
// @ts-ignore
|
|
await entry.getData(blobWriter);
|
|
const blob = await blobWriter.getData();
|
|
|
|
content = new BlobReader(blob)
|
|
zipEntriesToAdd.push({filename, content})
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
for(const {filename, content, options} of zipEntriesToAdd) {
|
|
await writer.add(filename, content, options);
|
|
}
|
|
|
|
const newZipFilenames = new Set(zipEntriesToAdd.map(ze => ze.filename))
|
|
|
|
if(!manifestFileData) {
|
|
throw new Error(`'META-INF/manifest.xml' zip entry missing`)
|
|
}
|
|
|
|
// remove ignored files from manifest.xml
|
|
for(const filename of manifestFileData.fileEntries.keys()) {
|
|
if(!newZipFilenames.has(filename)) {
|
|
manifestFileData.fileEntries.delete(filename)
|
|
}
|
|
}
|
|
|
|
const manifestFileXml = makeManifestFile(manifestFileData)
|
|
await writer.add('META-INF/manifest.xml', new TextReader(manifestFileXml));
|
|
|
|
await reader.close();
|
|
|
|
return writer.close();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|