Properly support currency fields

* restore test

* suppression de l'appel à lockdown par défaut

* improving readme

* ses@1.14

* add section on securing fillOdtTemplate

package-lock.json

@@ -1,16 +1,17 @@
 {
   "name": "@odfjs/odfjs",
-  "version": "0.24.0",
+  "version": "0.30.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@odfjs/odfjs",
-      "version": "0.24.0",
+      "version": "0.30.0",
       "dependencies": {
         "@xmldom/xmldom": "^0.9.8",
         "@zip.js/zip.js": "^2.7.57",
-        "ses": "^1.12.0"
+        "image-size": "^2.0.2",
+        "ses": "^1.14.0"
       },
       "devDependencies": {
         "@rollup/plugin-commonjs": "^25.0.7",
@@ -41,10 +42,22 @@
         "node": ">=6.0.0"
       }
     },
+    "node_modules/@endo/cache-map": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@endo/cache-map/-/cache-map-1.1.0.tgz",
+      "integrity": "sha512-owFGshs/97PDw9oguZqU/px8Lv1d0KjAUtDUiPwKHNXRVUE/jyettEbRoTbNJR1OaI8biMn6bHr9kVJsOh6dXw==",
+      "license": "Apache-2.0"
+    },
     "node_modules/@endo/env-options": {
-      "version": "1.1.8",
-      "resolved": "https://registry.npmjs.org/@endo/env-options/-/env-options-1.1.8.tgz",
-      "integrity": "sha512-Xtxw9n33I4guo8q0sDyZiRuxlfaopM454AKiELgU7l3tqsylCut6IBZ0fPy4ltSHsBib7M3yF7OEMoIuLwzWVg==",
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/@endo/env-options/-/env-options-1.1.11.tgz",
+      "integrity": "sha512-p9OnAPsdqoX4YJsE98e3NBVhIr2iW9gNZxHhAI2/Ul5TdRfoOViItzHzTqrgUVopw6XxA1u1uS6CykLMDUxarA==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@endo/immutable-arraybuffer": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@endo/immutable-arraybuffer/-/immutable-arraybuffer-1.1.2.tgz",
+      "integrity": "sha512-u+NaYB2aqEugQ3u7w3c5QNkPogf8q/xGgsPaqdY6pUiGWtYiTiFspKFcha6+oeZhWXWQ23rf0KrUq0kfuzqYyQ==",
       "license": "Apache-2.0"
     },
     "node_modules/@jridgewell/gen-mapping": {
@@ -2185,6 +2198,18 @@
         "node": ">=10 <11 || >=12 <13 || >=14"
       }
     },
+    "node_modules/image-size": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/image-size/-/image-size-2.0.2.tgz",
+      "integrity": "sha512-IRqXKlaXwgSMAMtpNzZa1ZAe8m+Sa1770Dhk8VkSsP9LS+iHD62Zd8FQKs8fbPiagBE7BzoFX23cxFnwshpV6w==",
+      "license": "MIT",
+      "bin": {
+        "image-size": "bin/image-size.js"
+      },
+      "engines": {
+        "node": ">=16.x"
+      }
+    },
     "node_modules/immutable": {
       "version": "4.2.4",
       "resolved": "https://registry.npmjs.org/immutable/-/immutable-4.2.4.tgz",
@@ -3615,12 +3640,14 @@
       }
     },
     "node_modules/ses": {
-      "version": "1.12.0",
-      "resolved": "https://registry.npmjs.org/ses/-/ses-1.12.0.tgz",
-      "integrity": "sha512-jvmwXE2lFxIIY1j76hFjewIIhYMR9Slo3ynWZGtGl5M7VUCw3EA0wetS+JCIbl2UcSQjAT0yGAHkyxPJreuC9w==",
+      "version": "1.14.0",
+      "resolved": "https://registry.npmjs.org/ses/-/ses-1.14.0.tgz",
+      "integrity": "sha512-T07hNgOfVRTLZGwSS50RnhqrG3foWP+rM+Q5Du4KUQyMLFI3A8YA4RKl0jjZzhihC1ZvDGrWi/JMn4vqbgr/Jg==",
       "license": "Apache-2.0",
       "dependencies": {
-        "@endo/env-options": "^1.1.8"
+        "@endo/cache-map": "^1.1.0",
+        "@endo/env-options": "^1.1.11",
+        "@endo/immutable-arraybuffer": "^1.1.2"
       }
     },
     "node_modules/set-blocking": {
@@ -4571,10 +4598,20 @@
         "@jridgewell/trace-mapping": "^0.3.9"
       }
     },
+    "@endo/cache-map": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@endo/cache-map/-/cache-map-1.1.0.tgz",
+      "integrity": "sha512-owFGshs/97PDw9oguZqU/px8Lv1d0KjAUtDUiPwKHNXRVUE/jyettEbRoTbNJR1OaI8biMn6bHr9kVJsOh6dXw=="
+    },
     "@endo/env-options": {
-      "version": "1.1.8",
-      "resolved": "https://registry.npmjs.org/@endo/env-options/-/env-options-1.1.8.tgz",
-      "integrity": "sha512-Xtxw9n33I4guo8q0sDyZiRuxlfaopM454AKiELgU7l3tqsylCut6IBZ0fPy4ltSHsBib7M3yF7OEMoIuLwzWVg=="
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/@endo/env-options/-/env-options-1.1.11.tgz",
+      "integrity": "sha512-p9OnAPsdqoX4YJsE98e3NBVhIr2iW9gNZxHhAI2/Ul5TdRfoOViItzHzTqrgUVopw6XxA1u1uS6CykLMDUxarA=="
+    },
+    "@endo/immutable-arraybuffer": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@endo/immutable-arraybuffer/-/immutable-arraybuffer-1.1.2.tgz",
+      "integrity": "sha512-u+NaYB2aqEugQ3u7w3c5QNkPogf8q/xGgsPaqdY6pUiGWtYiTiFspKFcha6+oeZhWXWQ23rf0KrUq0kfuzqYyQ=="
     },
     "@jridgewell/gen-mapping": {
       "version": "0.3.2",
@@ -6129,6 +6166,11 @@
       "integrity": "sha512-yiWd4GVmJp0Q6ghmM2B/V3oZGRmjrKLXvHR3TE1nfoXsmoggllfZUQe74EN0fJdPFZu2NIvNdrMMLm3OsV7Ohw==",
       "dev": true
     },
+    "image-size": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/image-size/-/image-size-2.0.2.tgz",
+      "integrity": "sha512-IRqXKlaXwgSMAMtpNzZa1ZAe8m+Sa1770Dhk8VkSsP9LS+iHD62Zd8FQKs8fbPiagBE7BzoFX23cxFnwshpV6w=="
+    },
     "immutable": {
       "version": "4.2.4",
       "resolved": "https://registry.npmjs.org/immutable/-/immutable-4.2.4.tgz",
@@ -7138,11 +7180,13 @@
       }
     },
     "ses": {
-      "version": "1.12.0",
-      "resolved": "https://registry.npmjs.org/ses/-/ses-1.12.0.tgz",
-      "integrity": "sha512-jvmwXE2lFxIIY1j76hFjewIIhYMR9Slo3ynWZGtGl5M7VUCw3EA0wetS+JCIbl2UcSQjAT0yGAHkyxPJreuC9w==",
+      "version": "1.14.0",
+      "resolved": "https://registry.npmjs.org/ses/-/ses-1.14.0.tgz",
+      "integrity": "sha512-T07hNgOfVRTLZGwSS50RnhqrG3foWP+rM+Q5Du4KUQyMLFI3A8YA4RKl0jjZzhihC1ZvDGrWi/JMn4vqbgr/Jg==",
       "requires": {
-        "@endo/env-options": "^1.1.8"
+        "@endo/cache-map": "^1.1.0",
+        "@endo/env-options": "^1.1.11",
+        "@endo/immutable-arraybuffer": "^1.1.2"
       }
     },
     "set-blocking": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odfjs/odfjs",
-  "version": "0.24.0",
+  "version": "0.30.0",
   "type": "module",
   "exports": "./exports.js",
   "files": [
@@ -21,7 +21,7 @@
     "test": "ava"
   },
   "repository": {
-    "url": "https://github.com/odfjs/odfjs.git"
+    "url": "https://source.netsyms.com/PostalPortal/odfjs.git"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^25.0.7",
@@ -41,6 +41,7 @@
   "dependencies": {
     "@xmldom/xmldom": "^0.9.8",
     "@zip.js/zip.js": "^2.7.57",
-    "ses": "^1.12.0"
+    "image-size": "^2.0.2",
+    "ses": "^1.14.0"
   }
 }

readme.md

@@ -18,7 +18,7 @@ Small lib to parse/understand .odf files (.odt, .ods) in the browser and node.js
 ### Install
 
 ```sh
-npm i https://github.com/odfjs/odfjs.git#v0.24.0
+npm i https://github.com/odfjs/odfjs.git#v0.30.0
 ```
 
 
@@ -99,8 +99,7 @@ And then run the code:
 ```js
 import {join} from 'node:path';
 
-import {getOdtTemplate} from '../scripts/odf/odtTemplate-forNode.js'
-import {fillOdtTemplate} from '../scripts/node.js'
+import {getOdtTemplate, fillOdtTemplate} from '@odfjs/odfjs'
 
 // replace with your template path
 const templatePath = join(import.meta.dirname, './tests/data/template-anniversaire.odt')
@@ -126,6 +125,19 @@ There are also loops in the form:
 They can be used to generate lists or tables in .odt files from data and a template using this syntax
 
 
+#### Securing calls to fillOdtTemplate
+
+`fillOdtTemplate` evaluate arbitrary JavaScript code in `{#each <collection> as élément}` and `{#if <condition>}` and in `{<expression>}`
+
+By default, `fillOdtTemplate` limits access to global functions to only ECMAScript defaults via the use of [ses' Compartment](https://www.npmjs.com/package/ses#compartment), this prevents naïve data exfiltration
+
+However, `fillOdtTemplate` is vulnerable to [prototype pollution](https://cheatsheetseries.owasp.org/cheatsheets/Prototype_Pollution_Prevention_Cheat_Sheet.html) inside template code. Two main ways to be secure are:
+- control the set of possible templates
+- call ses' `lockdown` which freezes Javascript intrinsics before calling `fillOdtTemplate` (this may lead to incompatibilities)
+
+
+
+
 ### Demo
 
 https://odfjs.github.io/odfjs/
@@ -146,4 +158,3 @@ npm run dev
 I hope to be credited for the work on this repo
 
 Everything written by me and contributors to this repo is licenced under **CC0 1.0 (Public Domain)**
-

scripts/createOdsFile.js

@@ -10,7 +10,11 @@ const stylesXml = `<?xml version="1.0" encoding="UTF-8"?>
   xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0"
   xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0"
   office:version="1.2">
-  <office:styles/>
+  <office:styles>
+    <style:style style:name="boldcell" style:family="table-cell">
+      <style:text-properties fo:font-weight="bold"/>
+    </style:style>
+  </office:styles>
   <office:automatic-styles/>
   <office:master-styles/>
 </office:document-styles>`;
@@ -27,7 +31,7 @@ const manifestXml = `<?xml version="1.0" encoding="UTF-8"?>
  * @param {Map<SheetName, SheetRawContent>} sheetsData
  * @returns {Promise<ArrayBuffer>}
  */
-export async function createOdsFile(sheetsData) {
+export async function createOdsFile(sheetsData, currencyData = null) {
     // Create a new zip writer
     const zipWriter = new ZipWriter(new BlobWriter('application/vnd.oasis.opendocument.spreadsheet'));
 
@@ -45,7 +49,7 @@ export async function createOdsFile(sheetsData) {
         }
     );
 
-    const contentXml = generateContentFileXMLString(sheetsData);
+    const contentXml = generateContentFileXMLString(sheetsData, currencyData);
     zipWriter.add("content.xml", new TextReader(contentXml), {level: 9});
 
     zipWriter.add("styles.xml", new TextReader(stylesXml));
@@ -63,7 +67,7 @@ export async function createOdsFile(sheetsData) {
  * @param {Map<SheetName, SheetRawContent>} sheetsData
  * @returns {string}
  */
-function generateContentFileXMLString(sheetsData) {
+function generateContentFileXMLString(sheetsData, currencyData) {
     const doc = createDocument('urn:oasis:names:tc:opendocument:xmlns:office:1.0', 'office:document-content');
     const root = doc.documentElement;
 
@@ -75,6 +79,52 @@ function generateContentFileXMLString(sheetsData) {
     root.setAttribute('xmlns:fo', 'urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0');
     root.setAttribute('office:version', '1.2');
 
+    const styleNode = doc.createElement("office:automatic-styles");
+
+    var currencyStyleName = "currencyStyle";
+    if (currencyData != null) {
+        currencyStyleName = `currency${currencyData.currencyCode.toUpperCase()}`;
+        const numberStyle = doc.createElement("number:currency-style");
+        numberStyle.setAttribute("style:name", currencyStyleName);
+
+        const numberCurrencySymbolStyle = doc.createElement("number:currency-symbol");
+        numberCurrencySymbolStyle.setAttribute("number:language", "en");
+        numberCurrencySymbolStyle.setAttribute("number:country", currencyData.countryCode.toUpperCase());
+        numberCurrencySymbolStyle.textContent = currencyData.currencySymbol;
+        numberStyle.appendChild(numberCurrencySymbolStyle);
+
+        const numberCurrencyStyle = doc.createElement("number:number");
+        numberCurrencyStyle.setAttribute("number:min-integer-digits", "1");
+        numberCurrencyStyle.setAttribute("number:decimal-places", `${currencyData.decimalPlaces}`);
+        numberCurrencyStyle.setAttribute("number:min-decimal-places", `${currencyData.decimalPlaces}`);
+        numberCurrencyStyle.setAttribute("number:grouping", "true");
+        numberStyle.appendChild(numberCurrencyStyle);
+
+        styleNode.appendChild(numberStyle);
+
+        const currencyCellStyleNode = doc.createElement("style:style");
+        currencyCellStyleNode.setAttribute("style:name", "currencycell");
+        currencyCellStyleNode.setAttribute("style:family", "table-cell");
+        currencyCellStyleNode.setAttribute("style:data-style-name", currencyStyleName);
+
+        const currencyCellTableCellProperties = doc.createElement("style:table-cell-properties");
+
+        currencyCellStyleNode.appendChild(currencyCellTableCellProperties);
+
+        styleNode.appendChild(currencyCellStyleNode);
+    }
+
+    const boldCellStyleNode = doc.createElement("style:style");
+    boldCellStyleNode.setAttribute("style:name", "boldcell");
+    boldCellStyleNode.setAttribute("style:family", "table-cell");
+    const boldCellTextPropsNode = doc.createElement("style:text-properties");
+    boldCellTextPropsNode.setAttribute("fo:font-weight", "bold");
+    boldCellStyleNode.appendChild(boldCellTextPropsNode);
+    styleNode.appendChild(boldCellStyleNode);
+
+
+    root.appendChild(styleNode);
+
     const bodyNode = doc.createElement('office:body');
     root.appendChild(bodyNode);
 
@@ -87,8 +137,30 @@ function generateContentFileXMLString(sheetsData) {
         tableNode.setAttribute('table:name', sheetName);
         spreadsheetNode.appendChild(tableNode);
 
-        const columnNode = doc.createElement('table:table-column');
-        tableNode.appendChild(columnNode);
+        var columnsWidthChars = {};
+        for (let r = 0; r < sheetData.length; r++) {
+            for (let c = 0; c < sheetData[r].length; c++) {
+                var len = ((sheetData[r][c].display ?? sheetData[r][c].value) + "").length;
+                if (typeof columnsWidthChars[c] == "undefined") {
+                    columnsWidthChars[c] = len;
+                }
+                columnsWidthChars[c] = Math.max(columnsWidthChars[c], len);
+            }
+        }
+
+        for (var prop in columnsWidthChars) {
+            var columnNode = doc.createElement('table:table-column');
+            columnNode.setAttribute("table:style-name", "colwidth" + columnsWidthChars[prop]);
+            tableNode.appendChild(columnNode);
+
+            var columnWidthNode = doc.createElement("style:style");
+            columnWidthNode.setAttribute("style:name", "colwidth" + columnsWidthChars[prop]);
+            columnWidthNode.setAttribute("style:family", "table-column");
+            const columnWidthPropsNode = doc.createElement("style:table-column-properties");
+            columnWidthPropsNode.setAttribute("style:column-width", `${columnsWidthChars[prop] * 0.26}cm`);
+            columnWidthNode.appendChild(columnWidthPropsNode);
+            styleNode.appendChild(columnWidthNode);
+        }
 
         // Iterate through rows
         sheetData.forEach((row) => {
@@ -101,6 +173,10 @@ function generateContentFileXMLString(sheetsData) {
                 const cellType = convertCellType(cell.type);
                 cellNode.setAttribute('office:value-type', cellType);
 
+                if (cell.style && cell.style == "bold") {
+                    cellNode.setAttribute('table:style-name', "boldcell");
+                }
+
                 // Add value attribute based on type
                 if (cell.value !== null && cell.value !== undefined) {
                     switch (cellType) {
@@ -111,6 +187,14 @@ function generateContentFileXMLString(sheetsData) {
                             cellNode.setAttribute('office:value', cell.value.toString());
                             cellNode.setAttribute('office:value-type', 'percentage');
                             break;
+                        case 'currency':
+                            cellNode.setAttribute('office:value', cell.value.toString());
+                            cellNode.setAttribute('office:value-type', 'currency');
+                            if (currencyData != null) {
+                                cellNode.setAttribute("table:style-name", "currencycell");
+                                cellNode.setAttribute('office:currency', currencyData.currencyCode.toUpperCase());
+                            }
+                            break;
                         case 'date':
                             cellNode.setAttribute('office:date-value', cell.value.toString());
                             break;
@@ -126,7 +210,11 @@ function generateContentFileXMLString(sheetsData) {
 
                     if (cellType !== 'string') {
                         const textNode = doc.createElement('text:p');
-                        textNode.textContent = cell.value.toString();
+                        if (typeof cell.display != "undefined") {
+                            textNode.textContent = cell.display.toString();
+                        } else {
+                            textNode.textContent = cell.value.toString();
+                        }
                         cellNode.appendChild(textNode);
                     }
                 }

scripts/odf/odt/getOdtTextContent.js

@@ -7,7 +7,7 @@ import {parseXML, Node} from '../../DOMUtils.js'
  * @param {ODTFile} odtFile 
  * @returns {Promise<Document>}
  */
-async function getContentDocument(odtFile) {
+export async function getContentDocument(odtFile) {
     const reader = new ZipReader(new Uint8ArrayReader(new Uint8Array(odtFile)));
 
     const entries = await reader.getEntries();

scripts/odf/templating/fillOdtElementTemplate.js

@@ -1,5 +1,8 @@
 import {traverse, Node, getAncestors, findCommonAncestor} from "../../DOMUtils.js";
-import {closingIfMarker, eachClosingMarker, eachStartMarkerRegex, elseMarker, ifStartMarkerRegex, variableRegex} from './markers.js'
+import {closingIfMarker, eachClosingMarker, eachStartMarkerRegex, elseMarker, ifStartMarkerRegex, imageMarkerRegex, variableRegex} from './markers.js'
+import {isOdfjsImage} from "../../shared.js"
+import imageSize from "image-size";
+/** @import {OdfjsImage} from "../../types.js" */
 
 /**
  * @typedef TextPlaceToFill
@@ -14,7 +17,7 @@ class TemplateDOMBranch{
     /** @type {Node} */
     #leafNode
 
-    // ancestors with this.#ancestors[0] === this.#startNode and this.#ancestors.at(-1) === this.#leafNode
+    // ancestors with this.#ancestors[0] === this.#branchBaseNode and this.#ancestors.at(-1) === this.#leafNode
     /** @type {Node[]} */
     #ancestors
 
@@ -182,12 +185,18 @@ class TemplateBlock{
     /** @type {Node[]} */
     #middleContent;
 
+    /**@type {any} */
+    #addImageToOdtFile;
+
     /**
      * 
      * @param {Node} startNode 
      * @param {Node} endNode 
+     * @param {(OdfjsImage) => string} addImageToOdtFile
      */
-    constructor(startNode, endNode){
+    constructor(startNode, endNode, addImageToOdtFile){
+        this.#addImageToOdtFile = addImageToOdtFile
+
         // @ts-expect-error xmldom.Node
         this.#commonAncestor = findCommonAncestor(startNode, endNode)
 
@@ -231,13 +240,16 @@ class TemplateBlock{
         const startChild = this.startBranch.at(1)
         if(startChild /*&& startChild !== */){
             //console.log('[fillBlockContentTemplate] startChild', startChild.nodeName, startChild.textContent)
-            fillOdtElementTemplate(startChild, compartement)
+            fillOdtElementTemplate(startChild, compartement, this.#addImageToOdtFile)
         }
         //console.log('[fillBlockContentTemplate] after startChild')
 
-        for(const content of this.#middleContent){
-            fillOdtElementTemplate(content, compartement)
-        }
+        
+        // if content consists of several parts of an {#each}{/each}
+        // when arriving to the {/each}, it will be alone (and imbalanced)
+        // and will trigger an error
+        fillOdtElementTemplate(Array.from(this.#middleContent), compartement, this.#addImageToOdtFile)
+
         //console.log('[fillBlockContentTemplate] after middleContent')
 
         const endChild = this.endBranch.at(1)
@@ -246,7 +258,7 @@ class TemplateBlock{
 
         if(endChild){
             //console.log('[fillBlockContentTemplate] endChild', endChild.nodeName, endChild.textContent)
-            fillOdtElementTemplate(endChild, compartement)
+            fillOdtElementTemplate(endChild, compartement, this.#addImageToOdtFile)
         }
         //console.log('[fillBlockContentTemplate] after endChild')
 
@@ -344,7 +356,7 @@ class TemplateBlock{
             }
         }
 
-        return new TemplateBlock(startLeafCloneNode, endLeafCloneNode)
+        return new TemplateBlock(startLeafCloneNode, endLeafCloneNode, this.#addImageToOdtFile)
     }
 
 }
@@ -423,8 +435,9 @@ function findPlacesToFillInString(str, compartment) {
  * @param {Node} ifClosingMarkerNode 
  * @param {string} ifBlockConditionExpression 
  * @param {Compartment} compartment 
+ * // TODO type,addImageToOdtFile
  */
-function fillIfBlock(ifOpeningMarkerNode, ifElseMarkerNode, ifClosingMarkerNode, ifBlockConditionExpression, compartment) {
+function fillIfBlock(ifOpeningMarkerNode, ifElseMarkerNode, ifClosingMarkerNode, ifBlockConditionExpression, compartment, addImageToOdtFile) {
     //const docEl = ifOpeningMarkerNode.ownerDocument.documentElement
     
     const conditionValue = compartment.evaluate(ifBlockConditionExpression)
@@ -440,11 +453,11 @@ function fillIfBlock(ifOpeningMarkerNode, ifElseMarkerNode, ifClosingMarkerNode,
             ifElseMarkerNode.childNodes.length, ifElseMarkerNode.textContent
         )*/
 
-        thenTemplateBlock = new TemplateBlock(ifOpeningMarkerNode, ifElseMarkerNode)
-        elseTemplateBlock = new TemplateBlock(ifElseMarkerNode, ifClosingMarkerNode)
+        thenTemplateBlock = new TemplateBlock(ifOpeningMarkerNode, ifElseMarkerNode, addImageToOdtFile)
+        elseTemplateBlock = new TemplateBlock(ifElseMarkerNode, ifClosingMarkerNode, addImageToOdtFile)
     }
     else {
-        thenTemplateBlock = new TemplateBlock(ifOpeningMarkerNode, ifClosingMarkerNode)
+        thenTemplateBlock = new TemplateBlock(ifOpeningMarkerNode, ifClosingMarkerNode, addImageToOdtFile)
     }
 
     if(conditionValue) {
@@ -483,14 +496,15 @@ function fillIfBlock(ifOpeningMarkerNode, ifElseMarkerNode, ifClosingMarkerNode,
  * @param {string} itemExpression 
  * @param {Node} endNode 
  * @param {Compartment} compartment 
+ * // TODO type addImageToOdtFile
  */
-function fillEachBlock(startNode, iterableExpression, itemExpression, endNode, compartment) {
+function fillEachBlock(startNode, iterableExpression, itemExpression, endNode, compartment, addImageToOdtFile) {
     //console.log('fillEachBlock', iterableExpression, itemExpression)
 
     const docEl = startNode.ownerDocument.documentElement
     //console.log('[fillEachBlock] docEl', docEl.textContent)
 
-    const repeatedTemplateBlock = new TemplateBlock(startNode, endNode)
+    const repeatedTemplateBlock = new TemplateBlock(startNode, endNode, addImageToOdtFile)
 
     // Find the iterable in the data
     let iterable = compartment.evaluate(iterableExpression)
@@ -551,17 +565,49 @@ function fillEachBlock(startNode, iterableExpression, itemExpression, endNode, c
 }
 
 
+/**
+ * @param {string} str
+ * @param {Compartement} compartment
+ * @returns { {expression: string, odfjsImage: OdfjsImage | undefined} | undefined}
+ */
+function findImageMarker(str, compartment) {
+    const imageRexExp = new RegExp(imageMarkerRegex.source, 'g');
+    const match = imageRexExp.exec(str)
+
+    if (match===null){
+        return;
+    }
+
+    const expression = match[1]
+    const value = compartment.evaluate(expression)
+    
+    if (isOdfjsImage(value)) {
+        return { expression, odfjsImage: value}
+    } else {
+        return { expression }
+    }
+}
+
 const IF = ifStartMarkerRegex.source
 const EACH = eachStartMarkerRegex.source
 
+/** @typedef {Element | DocumentFragment | Document} RootElementArgument */
+
+
 /**
  * 
- * @param {Element | DocumentFragment | Document} rootElement 
+ * @param {RootElementArgument | RootElementArgument[]} rootElements
  * @param {Compartment} compartment 
+ * @param {(OdfjsImage) => string} addImageToOdtFile
  * @returns {void}
  */
-export default function fillOdtElementTemplate(rootElement, compartment) {
-    //console.log('[fillTemplatedOdtElement]', rootElement.nodeType, rootElement.nodeName, rootElement.textContent)
+export default function fillOdtElementTemplate(rootElements, compartment, addImageToOdtFile) {
+    
+    if(!Array.isArray(rootElements)){
+        rootElements = [rootElements]
+    }
+
+    //console.log('[fillTemplatedOdtElement]', rootElements.length, rootElements[0].nodeType, rootElements[0].nodeName, rootElements[0].textContent)
     //console.log('[fillTemplatedOdtElement]', rootElement.documentElement && rootElement.documentElement.textContent)
 
     let currentlyOpenBlocks = []
@@ -585,187 +631,245 @@ export default function fillOdtElementTemplate(rootElement, compartment) {
     // Traverse "in document order"
 
 
-    // @ts-ignore
-    traverse(rootElement, currentNode => {
-        //console.log('currentlyOpenBlocks', currentlyOpenBlocks)
+    for(const rootElement of rootElements){
 
-        const insideAnOpenBlock = currentlyOpenBlocks.length >= 1
+        // @ts-ignore
+        traverse(rootElement, currentNode => {
+            //console.log('currentlyOpenBlocks', currentlyOpenBlocks)
+            //console.log('eachOpeningMarkerNode', eachOpeningMarkerNode)
 
-        if(currentNode.nodeType === Node.TEXT_NODE) {
-            const text = currentNode.textContent || ''
+            const insideAnOpenBlock = currentlyOpenBlocks.length >= 1
 
-            /**
-             * looking for {#each x as y}
-             */
-            const eachStartMatch = text.match(eachStartMarkerRegex);
+            if(currentNode.nodeType === Node.TEXT_NODE) {
+                const text = currentNode.textContent || ''
 
-            if(eachStartMatch) {
-                //console.log('startMatch', startMatch)
+                /**
+                 * looking for {#each x as y}
+                 */
+                const eachStartMatch = text.match(eachStartMarkerRegex);
 
-                currentlyOpenBlocks.push(EACH)
+                if(eachStartMatch) {
+                    //console.log('startMatch', startMatch)
 
-                if(insideAnOpenBlock) {
-                    // do nothing 
-                }
-                else {
-                    let [_, _iterableExpression, _itemExpression] = eachStartMatch
+                    currentlyOpenBlocks.push(EACH)
 
-                    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
+                    if(insideAnOpenBlock) {
+                        // do nothing 
+                    }
+                    else {
+                        let [_, _iterableExpression, _itemExpression] = eachStartMatch
+
+                        eachBlockIterableExpression = _iterableExpression
+                        eachBlockItemExpression = _itemExpression
+                        eachOpeningMarkerNode = 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 ifClosingMarker = text.includes(closingIfMarker);
+                /**
+                 * Looking for {/each}
+                 */
+                const isEachClosingBlock = text.includes(eachClosingMarker)
 
-            if(ifClosingMarker) {
-                if(!insideAnOpenBlock)
-                    throw new Error('{/if} without a corresponding {#if}')
+                if(isEachClosingBlock) {
 
-                if(currentlyOpenBlocks.length === 1) {
-                    if(currentlyOpenBlocks[0] === IF) {
-                        ifClosingMarkerNode = currentNode
+                    //console.log('isEachClosingBlock', isEachClosingBlock, currentlyOpenBlocks)
 
-                        // found an {#if} and its corresponding {/if}
+                    if(!insideAnOpenBlock)
+                        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
-                        fillIfBlock(ifOpeningMarkerNode, ifElseMarkerNode, ifClosingMarkerNode, ifBlockConditionExpression, compartment)
+                        //console.log('start of fillEachBlock')
 
-                        ifOpeningMarkerNode = undefined
-                        ifElseMarkerNode = undefined
-                        ifClosingMarkerNode = undefined
-                        ifBlockConditionExpression = undefined
+                        fillEachBlock(eachOpeningMarkerNode, eachBlockIterableExpression, eachBlockItemExpression, eachClosingMarkerNode, compartment, addImageToOdtFile)
+
+                        //console.log('end of fillEachBlock')
+
+                        eachOpeningMarkerNode = undefined
+                        eachBlockIterableExpression = undefined
+                        eachBlockItemExpression = undefined
+                        eachClosingMarkerNode = undefined
+                    }
+                    else {
+                        // ignore because it will be treated as part of the outer {#each}
+                    }
+
+                    //console.log('popping currentlyOpenBlocks')
+                    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 ifClosingMarker = text.includes(closingIfMarker);
+
+                if(ifClosingMarker) {
+                    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, addImageToOdtFile)
+
+                            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
+                    }
+
+                    currentlyOpenBlocks.pop()
+                }
+
+
+                /**
+                 * 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 {
+                            const imageMarker = findImageMarker(currentNode.data, compartment)
+                            if (imageMarker){
+                                //console.log({imageMarker}, "dans le if imageMarker")
+                                if (imageMarker.odfjsImage) {
+                                    const href  = addImageToOdtFile(imageMarker.odfjsImage)
+
+                                    const newImageNode = currentNode.ownerDocument?.createElement("draw:image")
+                                    newImageNode.setAttribute("xlink:href", href)
+                                    newImageNode.setAttribute("xlink:type", "simple")
+                                    newImageNode.setAttribute("xlink:show", "embed")
+                                    newImageNode.setAttribute("xlink:actuate", "onLoad")
+                                    newImageNode.setAttribute("draw:mime-type", imageMarker.odfjsImage.mediaType)
+
+                                    const newFrameNode = currentNode.ownerDocument?.createElement('draw:frame')
+                                    newFrameNode.setAttribute("text:anchor-type", "as-char")
+                                    const buffer = new Uint8Array(imageMarker.odfjsImage.content)
+                                    
+                                    const dimensions = imageSize(buffer)
+
+                                    const MAX_WIDTH = 10 // cm
+                                    const MAX_HEIGHT = 10 // cm
+
+                                    let width;
+                                    let height;
+
+                                    if(dimensions.width > dimensions.height){
+                                        // image in landscape
+                                        width = MAX_WIDTH;
+                                        height = width*dimensions.height/dimensions.width
+                                    }
+                                    else{
+                                        // image in portrait
+                                        height = MAX_HEIGHT;
+                                        width = height*dimensions.width/dimensions.height
+                                    }
+
+                                    newFrameNode.setAttribute("svg:width", `${width}cm`)
+                                    newFrameNode.setAttribute("svg:height", `${height}cm`)
+                                    newFrameNode.appendChild(newImageNode)
+
+                                    currentNode.parentNode?.replaceChild(newFrameNode, currentNode)                                
+                                } else {
+                                    throw new Error(`No valid OdfjsImage value has been found for expression: ${imageMarker.expression}`)
+                                }
+                            }
+                            
+
+                        }
                     }
-                    else
-                        throw new Error('{/if} inside an {#each} but without a corresponding {#if}')
                 }
                 else {
-                    // do nothing because the marker is too deep
+                    // ignore because it will be treated as part of the outer {#each} block
                 }
-
-                currentlyOpenBlocks.pop()
             }
 
-
-            /**
-             * Looking for variables for substitutions
-             */
-            if(!insideAnOpenBlock) {
-                // @ts-ignore
-                if(currentNode.data) {
+            if(currentNode.nodeType === Node.ATTRIBUTE_NODE) {
+                // Looking for variables for substitutions
+                if(!insideAnOpenBlock) {
                     // @ts-ignore
-                    const placesToFill = findPlacesToFillInString(currentNode.data, compartment)
-
-                    if(placesToFill) {
-                        const newText = placesToFill.fill()
+                    if(currentNode.value) {
                         // @ts-ignore
-                        const newTextNode = currentNode.ownerDocument?.createTextNode(newText)
-                        // @ts-ignore
-                        currentNode.parentNode?.replaceChild(newTextNode, currentNode)
+                        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 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
                 }
             }
-            else {
-                // ignore because it will be treated as part of the {#each} block
-            }
-        }
-    })
+        })
+
+    }
 }

scripts/odf/templating/fillOdtTemplate.js

@@ -7,11 +7,10 @@ import prepareTemplateDOMTree from './prepareTemplateDOMTree.js';
 import 'ses'
 import fillOdtElementTemplate from './fillOdtElementTemplate.js';
 
-lockdown();
-
 
 /** @import {Reader, ZipWriterAddDataOptions} from '@zip.js/zip.js' */
-/** @import {ODFManifest} from '../manifest.js' */
+/** @import {ODFManifest, ODFManifestFileEntry} from '../manifest.js' */
+/** @import {OdfjsImage} from '../../types.js' */
 
 /** @typedef {ArrayBuffer} ODTFile */
 
@@ -23,11 +22,12 @@ const ODTMimetype = 'application/vnd.oasis.opendocument.text'
  * 
  * @param {Document} document 
  * @param {Compartment} compartment 
+ * @param {(OdfjsImage) => string} addImageToOdtFile
  * @returns {void}
  */
-function fillOdtDocumentTemplate(document, compartment) {
+function fillOdtDocumentTemplate(document, compartment, addImageToOdtFile) {
     prepareTemplateDOMTree(document)
-    fillOdtElementTemplate(document, compartment)
+    fillOdtElementTemplate(document, compartment, addImageToOdtFile)
 }
 
 
@@ -64,6 +64,21 @@ export default async function fillOdtTemplate(odtTemplate, data) {
 
     /** @type {{filename: string, content: Reader, options?: ZipWriterAddDataOptions}[]} */
     const zipEntriesToAdd = []
+    /** @type {ODFManifestFileEntry[]} */
+    const newManifestEntries = []
+
+    /** 
+     * Return href
+     * @param {OdfjsImage} odfjsImage
+     * @returns {string}
+    */
+    function addImageToOdtFile(odfjsImage) {
+        // console.log({odfjsImage})
+        const filename = `Pictures/${odfjsImage.fileName}`
+        zipEntriesToAdd.push({content: new Uint8ArrayReader(new Uint8Array(odfjsImage.content)), filename})
+        newManifestEntries.push({fullPath: filename, mediaType: odfjsImage.mediaType})
+        return filename
+    }
 
     // Parcourir chaque entrée du fichier ODT
     for await(const entry of entries) {
@@ -97,12 +112,14 @@ export default async function fillOdtTemplate(odtTemplate, data) {
                     const contentXml = await entry.getData(new TextWriter());
                     const contentDocument = parseXML(contentXml);
                     
+
+
                     const compartment = new Compartment({
                         globals: data,
                         __options__: true
                     })
 
-                    fillOdtDocumentTemplate(contentDocument, compartment)
+                    fillOdtDocumentTemplate(contentDocument, compartment, addImageToOdtFile)
 
                     const updatedContentXml = serializeToString(contentDocument)
 
@@ -138,6 +155,9 @@ export default async function fillOdtTemplate(odtTemplate, data) {
         }
     }
 
+    for(const {fullPath, mediaType} of newManifestEntries){
+        manifestFileData.fileEntries.set(fullPath, {fullPath, mediaType})
+    }
 
     for(const {filename, content, options} of zipEntriesToAdd) {
         await writer.add(filename, content, options);

scripts/odf/templating/markers.js

@@ -1,5 +1,6 @@
 // the regexps below are shared, so they shoudn't have state (no 'g' flag)
 export const variableRegex = /\{([^{#\/:]+?)\}/
+export const imageMarkerRegex = /{#image\s+([^}]+?)\s*}/;
 
 export const ifStartMarkerRegex = /{#if\s+([^}]+?)\s*}/;
 export const elseMarker = '{:else}'

scripts/shared.js

@@ -4,7 +4,7 @@ import { Uint8ArrayReader, ZipReader, TextWriter } from '@zip.js/zip.js';
 import {parseXML} from './DOMUtils.js'
 
 /** @import {Entry} from '@zip.js/zip.js'*/
-/** @import {SheetName, SheetRawContent, SheetRowRawContent, SheetCellRawContent} from './types.js' */
+/** @import {SheetName, SheetRawContent, SheetRowRawContent, SheetCellRawContent, OdfjsImage} from './types.js' */
 
 
 // https://dom.spec.whatwg.org/#interface-node
@@ -18,7 +18,6 @@ const TEXT_NODE = 3
 function extraxtODSCellText(cell) {
     let text = '';
     const childNodes = cell.childNodes;
-
     for (const child of Array.from(childNodes)) {
         if (child.nodeType === TEXT_NODE) {
             // Direct text node, append the text directly
@@ -34,6 +33,8 @@ function extraxtODSCellText(cell) {
                     text += pChild.nodeValue;  // Append text inside <text:p>
                 } else if (pChild.nodeName === 'text:line-break') {
                     text += '\n';  // Append newline for <text:line-break />
+                } else if (pChild.nodeName === 'text:a' || pChild.nodeName === 'text:span') {
+                    text += pChild.textContent
                 }
             }
         } else if (child.nodeName === 'text:line-break') {
@@ -160,6 +161,22 @@ export function convertCellValue({value, type}) {
 }
 
 
+/**
+ * @param {unknown} value
+ * @returns {value is OdfjsImage}
+ */
+export function isOdfjsImage(value) {
+    if (typeof value === 'object' && value!==null
+        && "content" in value && value.content instanceof ArrayBuffer
+        && "fileName" in value && typeof value.fileName === 'string'
+        && "mediaType" in value && typeof value.mediaType === 'string'
+    ) {
+        return true
+    } else {
+        return false
+    }
+}
+
 
 
 

scripts/types.js

@@ -10,4 +10,12 @@
 
 /** @typedef {string} SheetName */
 
+/** 
+ * @typedef OdfjsImage  
+ * @prop {ArrayBuffer} content
+ * @prop {string} fileName
+ * @prop {string} mediaType
+ * 
+*/
+
 export {}

tests/fill-odt-template/complex.js

@@ -0,0 +1,25 @@
+import test from 'ava';
+import {join} from 'node:path';
+
+import {getOdtTemplate} from '../../scripts/odf/odtTemplate-forNode.js'
+
+import {fillOdtTemplate, getOdtTextContent} from '../../exports.js'
+
+
+test('template with {#each} inside an {#if}', async t => {
+    const templatePath = join(import.meta.dirname, '../fixtures/if-then-each.odt')
+    const templateContent = `{#if liste_départements.length >= 2}{#each liste_départements as département}{département}, {/each} {/if}`
+
+    const data = {liste_départements : ['95', '33']}
+
+    const odtTemplate = await getOdtTemplate(templatePath)
+    const templateTextContent = await getOdtTextContent(odtTemplate)
+    t.deepEqual(templateTextContent.trim(), templateContent.trim(), 'reconnaissance du template')
+
+    const odtResult = await fillOdtTemplate(odtTemplate, data)
+
+    const odtResultTextContent = await getOdtTextContent(odtResult)
+    t.deepEqual(odtResultTextContent.trim(), `95, 33,`)
+
+});
+

tests/fill-odt-template/each.js

@@ -344,3 +344,32 @@ Année
 `.trim())
 
 });
+
+
+test('nested each without common ancestor for inner each', async t => {
+    const templatePath = join(import.meta.dirname, '../fixtures/nested-each-without-common-ancestor-for-inner-each.odt')
+    const templateContent = `{#each liste_espèces_par_impact as élément}
+{#each élément.liste_espèces as espèce}
+{/each}
+{/each}
+`
+
+	const data = {
+        liste_espèces_par_impact: [
+            {}
+        ]
+    }
+
+    const odtTemplate = await getOdtTemplate(templatePath)
+
+    const templateTextContent = await getOdtTextContent(odtTemplate)
+
+    t.deepEqual(templateTextContent, templateContent, 'reconnaissance du template')
+
+    const odtResult = await fillOdtTemplate(odtTemplate, data)
+
+    const odtResultTextContent = await getOdtTextContent(odtResult)
+    t.deepEqual(odtResultTextContent, ``)
+
+
+});

tests/fill-odt-template/image.js

@@ -1,10 +1,12 @@
 import test from 'ava';
 import {join} from 'node:path';
+import { readFile } from 'node:fs/promises'
 
 import {getOdtTemplate} from '../../scripts/odf/odtTemplate-forNode.js'
 
-import {fillOdtTemplate} from '../../exports.js'
+import {fillOdtTemplate, getOdtTextContent} from '../../exports.js'
 import { listZipEntries } from '../helpers/zip-analysis.js';
+import { getContentDocument } from '../../scripts/odf/odt/getOdtTextContent.js';
 
 
 test('template filling preserves images', async t => {
@@ -36,3 +38,47 @@ test('template filling preserves images', async t => {
     )
 
 })
+
+test('insert 2 images', async t => {
+    const templatePath = join(import.meta.dirname, '../fixtures/basic-image-insertion.odt')
+
+    
+    const odtTemplate = await getOdtTemplate(templatePath)
+    const templateContent = `{title}
+
+{#each photos as photo}
+{#image photo}
+{/each}
+`
+    const templateTextContent = await getOdtTextContent(odtTemplate)
+
+    t.is(templateTextContent, templateContent, 'reconnaissance du template')
+
+    const photo1Path = join(import.meta.dirname, '../fixtures/pitchou-1.png')
+    const photo2Path = join(import.meta.dirname, '../fixtures/pitchou-2.png')
+
+    const photo1Buffer = (await readFile(photo1Path)).buffer
+    const photo2Buffer = (await readFile(photo2Path)).buffer
+
+    const photos = [{content: photo1Buffer, fileName: 'pitchou-1.png', mediaType: 'image/png'}, {content: photo2Buffer, fileName: 'pitchou-2.png', mediaType: 'image/png'}]
+
+    const data = {
+        title: 'Titre de mon projet',
+        photos,
+    }
+
+    const odtResult = await fillOdtTemplate(odtTemplate, data)
+    const resultEntries = await listZipEntries(odtResult)
+    
+    
+    t.is(
+        resultEntries.filter(entry => entry.filename.startsWith('Pictures/')).length, 2, 
+        `Two pictures in 'Pictures/' folder are expected`
+    )
+
+    const odtContentDocument = await getContentDocument(odtResult)
+
+    const drawImageElements = odtContentDocument.getElementsByTagName('draw:image')
+    t.is(drawImageElements.length, 2, 'Two draw:image elements should be in the generated document.')
+   
+})

tests/ods-files.js

@@ -56,3 +56,33 @@ Si t'es pas comme eux quand t'es naturel`
 
     t.deepEqual(feuille1[0][0].value, expectedValue)
 });
+
+test('.ods cells with mails should be recognized', async t => {
+    const odsFileWithEmails = (await readFile('./tests/fixtures/cellules avec emails.ods')).buffer
+	const table = await getODSTableRawContent(odsFileWithEmails);
+
+    const feuille1 = table.get('Feuille1')
+
+    const row1 = feuille1[0]
+    t.deepEqual(row1[0].value, 'Nom')
+    t.deepEqual(row1[1].value, 'Email')
+
+    const row2 = feuille1[1]
+
+    t.deepEqual(row2[0].value, 'Dav')
+    t.deepEqual(row2[1].value, 'david@example.org')
+
+    const row3 = feuille1[2]
+    t.deepEqual(row3[0].value, 'Fanny')
+    t.deepEqual(row3[1].value, 'lemaildeFanny@example.com')
+});
+
+test('.ods cells with partially styled content should be recognized', async t => {
+    const odsFileWithStyle = (await readFile('./tests/fixtures/cellule avec style.ods')).buffer;
+    const table = await getODSTableRawContent(odsFileWithStyle);
+
+    const feuille1 = table.get('Feuille1');
+
+    const row1 = feuille1[0];
+    t.deepEqual(row1[0].value, 'Toto titi');
+});

tools/create-odt-file-from-template.js

@@ -1,4 +1,4 @@
-import {writeFile} from 'node:fs/promises'
+import {writeFile, readFile} from 'node:fs/promises'
 import {join} from 'node:path';
 
 import {getOdtTemplate} from '../scripts/odf/odtTemplate-forNode.js'
@@ -103,6 +103,7 @@ const templatePath = join(import.meta.dirname, '../tests/fixtures/partially-form
 const data = {nombre : 37}
 */  
 
+/*
 const templatePath = join(import.meta.dirname, '../tests/fixtures/text-after-closing-each.odt')
 const data = {
     saison: 'Printemps',
@@ -112,7 +113,34 @@ const data = {
         'Blette'
     ]
 }
+*/
+// const templatePath = join(import.meta.dirname, '../tests/fixtures/text-after-closing-each.odt')
+// const data = {
+//     saison: 'Printemps',
+//     légumes: [
+//         'Asperge',
+//         'Betterave',
+//         'Blette'
+//     ]
+// }
 
+// const templatePath = join(import.meta.dirname, '../tests/fixtures/if-then-each.odt')
+// const data = {liste_départements : ['95', '33']}
+
+
+const templatePath = join(import.meta.dirname, '../tests/fixtures/basic-image-insertion.odt')
+const photo1Path = join(import.meta.dirname, '../tests/fixtures/pitchou-1.png')
+const photo2Path = join(import.meta.dirname, '../tests/fixtures/pitchou-2.png')
+
+const photo1Buffer = (await readFile(photo1Path)).buffer
+const photo2Buffer = (await readFile(photo2Path)).buffer
+
+const photos = [{content: photo1Buffer, fileName: 'pitchou-1.png', mediaType: 'image/png'}, {content: photo2Buffer, fileName: 'pitchou-2.png', mediaType: 'image/png'}]
+
+const data = {
+    title: 'Titre de mon projet',
+    photos,
+}
 
 
 const odtTemplate = await getOdtTemplate(templatePath)