@sync-in/server 1.3.0

package/server/applications/files/utils/doc-textify/adapters/pdf.js

@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>
+ * This file is part of Sync-in | The open source file sync and share solution
+ * See the LICENSE file for licensing details
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parsePdf", {
+    enumerable: true,
+    get: function() {
+        return parsePdf;
+    }
+});
+const _pdf = require("pdfjs-dist/legacy/build/pdf.mjs");
+// Enable parallel PDF parsing via Node.js worker threads
+_pdf.GlobalWorkerOptions.workerSrc = require.resolve('pdfjs-dist/legacy/build/pdf.worker.mjs');
+// Type guard to filter true text items
+function isTextItem(item) {
+    return typeof item.str === 'string' && Array.isArray(item.transform);
+}
+const ignorePdfBadFormat = new Set([
+    0x0000,
+    0x0001
+]);
+async function parsePdf(filePath, options) {
+    let doc;
+    try {
+        // Load the document, allowing system fonts as fallback
+        const loadingTask = (0, _pdf.getDocument)({
+            url: filePath,
+            useSystemFonts: true
+        });
+        doc = await loadingTask.promise;
+        const fragments = [];
+        let lastY = undefined;
+        for(let pageNum = 1; pageNum <= doc.numPages; pageNum++){
+            const page = await doc.getPage(pageNum);
+            const { items } = await page.getTextContent();
+            for (const item of items){
+                // Skip non-text items
+                if (!isTextItem(item)) continue;
+                const currentY = item.transform[5];
+                if (lastY !== undefined && currentY !== lastY) {
+                    fragments.push(options.newlineDelimiter);
+                }
+                fragments.push(item.str);
+                lastY = currentY;
+            }
+            page.cleanup();
+        }
+        const content = fragments.join('');
+        if (ignorePdfBadFormat.has(content.charCodeAt(0))) {
+            return '';
+        }
+        return content;
+    } catch (e) {
+        if (options.outputErrorToConsole) {
+            console.error('Error parsing PDF:', e);
+        }
+        throw e;
+    } finally{
+        doc?.destroy().catch((e)=>console.error(e));
+    }
+}
+
+//# sourceMappingURL=pdf.js.map

package/server/applications/files/utils/doc-textify/adapters/pdf.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../backend/src/applications/files/utils/doc-textify/adapters/pdf.ts"],"sourcesContent":["/*\n * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>\n * This file is part of Sync-in | The open source file sync and share solution\n * See the LICENSE file for licensing details\n */\nimport { getDocument, GlobalWorkerOptions, PDFDocumentProxy } from 'pdfjs-dist/legacy/build/pdf.mjs'\nimport { DocTextifyOptions } from '../interfaces/doc-textify.interfaces'\n\n// Enable parallel PDF parsing via Node.js worker threads\nGlobalWorkerOptions.workerSrc = require.resolve('pdfjs-dist/legacy/build/pdf.worker.mjs')\n\n// Type guard to filter true text items\nfunction isTextItem(item: any): item is { str: string; transform: [number, number, number, number, number, number] } {\n  return typeof item.str === 'string' && Array.isArray(item.transform)\n}\n\nconst ignorePdfBadFormat = new Set([0x0000, 0x0001])\n\n/** Parse PDF files */\nexport async function parsePdf(filePath: string, options: DocTextifyOptions): Promise<string> {\n  let doc: PDFDocumentProxy\n\n  try {\n    // Load the document, allowing system fonts as fallback\n    const loadingTask = getDocument({ url: filePath, useSystemFonts: true })\n    doc = await loadingTask.promise\n    const fragments: string[] = []\n    let lastY: number | undefined = undefined\n\n    for (let pageNum = 1; pageNum <= doc.numPages; pageNum++) {\n      const page = await doc.getPage(pageNum)\n      const { items } = await page.getTextContent()\n\n      for (const item of items) {\n        // Skip non-text items\n        if (!isTextItem(item)) continue\n\n        const currentY = item.transform[5]\n        if (lastY !== undefined && currentY !== lastY) {\n          fragments.push(options.newlineDelimiter)\n        }\n\n        fragments.push(item.str)\n        lastY = currentY\n      }\n      page.cleanup()\n    }\n\n    const content = fragments.join('')\n    if (ignorePdfBadFormat.has(content.charCodeAt(0))) {\n      return ''\n    }\n    return content\n  } catch (e) {\n    if (options.outputErrorToConsole) {\n      console.error('Error parsing PDF:', e)\n    }\n    throw e\n  } finally {\n    doc?.destroy().catch((e: Error) => console.error(e))\n  }\n}\n"],"names":["parsePdf","GlobalWorkerOptions","workerSrc","require","resolve","isTextItem","item","str","Array","isArray","transform","ignorePdfBadFormat","Set","filePath","options","doc","loadingTask","getDocument","url","useSystemFonts","promise","fragments","lastY","undefined","pageNum","numPages","page","getPage","items","getTextContent","currentY","push","newlineDelimiter","cleanup","content","join","has","charCodeAt","e","outputErrorToConsole","console","error","destroy","catch"],"mappings":"AAAA;;;;CAIC;;;;+BAeqBA;;;eAAAA;;;qBAd6C;AAGnE,yDAAyD;AACzDC,wBAAmB,CAACC,SAAS,GAAGC,QAAQC,OAAO,CAAC;AAEhD,uCAAuC;AACvC,SAASC,WAAWC,IAAS;IAC3B,OAAO,OAAOA,KAAKC,GAAG,KAAK,YAAYC,MAAMC,OAAO,CAACH,KAAKI,SAAS;AACrE;AAEA,MAAMC,qBAAqB,IAAIC,IAAI;IAAC;IAAQ;CAAO;AAG5C,eAAeZ,SAASa,QAAgB,EAAEC,OAA0B;IACzE,IAAIC;IAEJ,IAAI;QACF,uDAAuD;QACvD,MAAMC,cAAcC,IAAAA,gBAAW,EAAC;YAAEC,KAAKL;YAAUM,gBAAgB;QAAK;QACtEJ,MAAM,MAAMC,YAAYI,OAAO;QAC/B,MAAMC,YAAsB,EAAE;QAC9B,IAAIC,QAA4BC;QAEhC,IAAK,IAAIC,UAAU,GAAGA,WAAWT,IAAIU,QAAQ,EAAED,UAAW;YACxD,MAAME,OAAO,MAAMX,IAAIY,OAAO,CAACH;YAC/B,MAAM,EAAEI,KAAK,EAAE,GAAG,MAAMF,KAAKG,cAAc;YAE3C,KAAK,MAAMvB,QAAQsB,MAAO;gBACxB,sBAAsB;gBACtB,IAAI,CAACvB,WAAWC,OAAO;gBAEvB,MAAMwB,WAAWxB,KAAKI,SAAS,CAAC,EAAE;gBAClC,IAAIY,UAAUC,aAAaO,aAAaR,OAAO;oBAC7CD,UAAUU,IAAI,CAACjB,QAAQkB,gBAAgB;gBACzC;gBAEAX,UAAUU,IAAI,CAACzB,KAAKC,GAAG;gBACvBe,QAAQQ;YACV;YACAJ,KAAKO,OAAO;QACd;QAEA,MAAMC,UAAUb,UAAUc,IAAI,CAAC;QAC/B,IAAIxB,mBAAmByB,GAAG,CAACF,QAAQG,UAAU,CAAC,KAAK;YACjD,OAAO;QACT;QACA,OAAOH;IACT,EAAE,OAAOI,GAAG;QACV,IAAIxB,QAAQyB,oBAAoB,EAAE;YAChCC,QAAQC,KAAK,CAAC,sBAAsBH;QACtC;QACA,MAAMA;IACR,SAAU;QACRvB,KAAK2B,UAAUC,MAAM,CAACL,IAAaE,QAAQC,KAAK,CAACH;IACnD;AACF"}

package/server/applications/files/utils/doc-textify/adapters/power-point.js

@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>
+ * This file is part of Sync-in | The open source file sync and share solution
+ * See the LICENSE file for licensing details
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parsePowerPoint", {
+    enumerable: true,
+    get: function() {
+        return parsePowerPoint;
+    }
+});
+const _nodeutil = require("node:util");
+const _sax = /*#__PURE__*/ _interop_require_default(require("sax"));
+const _yauzl = require("yauzl");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const openZipAsync = (0, _nodeutil.promisify)(_yauzl.open);
+async function parsePowerPoint(filePath, options) {
+    // Regex to match slide and notes XML, capturing the slide index
+    const slidesRegex = /^ppt\/slides\/slide(\d+)\.xml$/;
+    const notesRegex = /^ppt\/notesSlides\/notesSlide(\d+)\.xml$|^ppt\/slides\/notesSlides\/slide(\d+)\.xml$/;
+    // Map of slide index -> array of text fragments
+    const slideTextMap = {};
+    let hasSlide = false;
+    // 1. Open the PPTX (ZIP) in lazyEntries mode
+    const zipFile = await openZipAsync(filePath, {
+        lazyEntries: true
+    });
+    return new Promise((resolve, reject)=>{
+        zipFile.readEntry();
+        zipFile.on('entry', (entry)=>{
+            const path = entry.fileName;
+            let match;
+            // Skip if not a slide or a note
+            const isSlide = slidesRegex.test(path);
+            const isNote = notesRegex.test(path);
+            if (!isSlide && !isNote) {
+                zipFile.readEntry();
+                return;
+            }
+            // Capture the regex match and flag that we've seen a slide
+            if (isSlide) {
+                match = slidesRegex.exec(path);
+                hasSlide = true;
+            } else {
+                match = notesRegex.exec(path);
+            }
+            // parse the slide number from whichever capture is defined
+            const slideNum = parseInt(match[1] || match[2], 10);
+            if (!slideTextMap[slideNum]) slideTextMap[slideNum] = [];
+            // 2. Open a read stream for this entry
+            zipFile.openReadStream(entry, (err, readStream)=>{
+                if (err) {
+                    zipFile.close();
+                    return reject(err);
+                }
+                // 3. SAX parser to extract <a:t> text nodes
+                const parser = _sax.default.createStream(true);
+                let buffer = '';
+                parser.on('error', (parseErr)=>{
+                    readStream.destroy();
+                    zipFile.close();
+                    reject(parseErr);
+                });
+                parser.on('opentag', (node)=>{
+                    if (node.name === 'a:t') {
+                        buffer = '';
+                    }
+                });
+                parser.on('text', (txt)=>{
+                    buffer += txt;
+                });
+                parser.on('closetag', (name)=>{
+                    if (name === 'a:t') {
+                        slideTextMap[slideNum].push(buffer);
+                    }
+                });
+                readStream.on('error', (streamErr)=>{
+                    zipFile.close();
+                    reject(streamErr);
+                }).on('end', ()=>{
+                    // Move on to the next entry
+                    zipFile.readEntry();
+                }).pipe(parser);
+            });
+        });
+        zipFile.on('end', ()=>{
+            zipFile.close();
+            // 4. Ensure at least one slide was found
+            if (!hasSlide) {
+                return reject(new Error('file seems to be corrupted'));
+            }
+            // 5. Build final output by ascending slide number
+            const sortedSlides = Object.keys(slideTextMap).map((n)=>parseInt(n, 10)).sort((a, b)=>a - b);
+            const result = sortedSlides.map((num)=>slideTextMap[num].join(options.newlineDelimiter)).join(options.newlineDelimiter);
+            resolve(result);
+        });
+        zipFile.on('error', (zipErr)=>{
+            zipFile.close();
+            reject(zipErr);
+        });
+    });
+}
+
+//# sourceMappingURL=power-point.js.map

package/server/applications/files/utils/doc-textify/adapters/power-point.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../backend/src/applications/files/utils/doc-textify/adapters/power-point.ts"],"sourcesContent":["/*\n * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>\n * This file is part of Sync-in | The open source file sync and share solution\n * See the LICENSE file for licensing details\n */\n\nimport { promisify } from 'node:util'\nimport sax from 'sax'\nimport { Entry, open as openZip, Options, ZipFile } from 'yauzl'\nimport { DocTextifyOptions } from '../interfaces/doc-textify.interfaces'\n\nconst openZipAsync: (path: string, options: Options) => Promise<ZipFile> = promisify(openZip)\n\n/**\n * Parses a PPTX file\n */\nexport async function parsePowerPoint(filePath: string, options: DocTextifyOptions): Promise<string> {\n  // Regex to match slide and notes XML, capturing the slide index\n  const slidesRegex = /^ppt\\/slides\\/slide(\\d+)\\.xml$/\n  const notesRegex = /^ppt\\/notesSlides\\/notesSlide(\\d+)\\.xml$|^ppt\\/slides\\/notesSlides\\/slide(\\d+)\\.xml$/\n\n  // Map of slide index -> array of text fragments\n  const slideTextMap: Record<number, string[]> = {}\n  let hasSlide = false\n\n  // 1. Open the PPTX (ZIP) in lazyEntries mode\n  const zipFile = await openZipAsync(filePath, { lazyEntries: true })\n\n  return new Promise<string>((resolve, reject) => {\n    zipFile.readEntry()\n\n    zipFile.on('entry', (entry: Entry) => {\n      const path = entry.fileName\n      let match: RegExpExecArray | null\n\n      // Skip if not a slide or a note\n      const isSlide = slidesRegex.test(path)\n      const isNote = notesRegex.test(path)\n      if (!isSlide && !isNote) {\n        zipFile.readEntry()\n        return\n      }\n\n      // Capture the regex match and flag that we've seen a slide\n      if (isSlide) {\n        match = slidesRegex.exec(path)!\n        hasSlide = true\n      } else {\n        match = notesRegex.exec(path)!\n      }\n\n      // parse the slide number from whichever capture is defined\n      const slideNum = parseInt(match[1] || match[2]!, 10)\n      if (!slideTextMap[slideNum]) slideTextMap[slideNum] = []\n\n      // 2. Open a read stream for this entry\n      zipFile.openReadStream(entry, (err, readStream) => {\n        if (err) {\n          zipFile.close()\n          return reject(err)\n        }\n\n        // 3. SAX parser to extract <a:t> text nodes\n        const parser = sax.createStream(true)\n        let buffer = ''\n\n        parser.on('error', (parseErr) => {\n          readStream.destroy()\n          zipFile.close()\n          reject(parseErr)\n        })\n\n        parser.on('opentag', (node) => {\n          if (node.name === 'a:t') {\n            buffer = ''\n          }\n        })\n\n        parser.on('text', (txt) => {\n          buffer += txt\n        })\n\n        parser.on('closetag', (name) => {\n          if (name === 'a:t') {\n            slideTextMap[slideNum].push(buffer)\n          }\n        })\n\n        readStream\n          .on('error', (streamErr) => {\n            zipFile.close()\n            reject(streamErr)\n          })\n          .on('end', () => {\n            // Move on to the next entry\n            zipFile.readEntry()\n          })\n          .pipe(parser)\n      })\n    })\n\n    zipFile.on('end', () => {\n      zipFile.close()\n      // 4. Ensure at least one slide was found\n      if (!hasSlide) {\n        return reject(new Error('file seems to be corrupted'))\n      }\n\n      // 5. Build final output by ascending slide number\n      const sortedSlides = Object.keys(slideTextMap)\n        .map((n) => parseInt(n, 10))\n        .sort((a, b) => a - b)\n\n      const result = sortedSlides.map((num) => slideTextMap[num].join(options.newlineDelimiter)).join(options.newlineDelimiter)\n\n      resolve(result)\n    })\n\n    zipFile.on('error', (zipErr) => {\n      zipFile.close()\n      reject(zipErr)\n    })\n  })\n}\n"],"names":["parsePowerPoint","openZipAsync","promisify","openZip","filePath","options","slidesRegex","notesRegex","slideTextMap","hasSlide","zipFile","lazyEntries","Promise","resolve","reject","readEntry","on","entry","path","fileName","match","isSlide","test","isNote","exec","slideNum","parseInt","openReadStream","err","readStream","close","parser","sax","createStream","buffer","parseErr","destroy","node","name","txt","push","streamErr","pipe","Error","sortedSlides","Object","keys","map","n","sort","a","b","result","num","join","newlineDelimiter","zipErr"],"mappings":"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"}

package/server/applications/files/utils/doc-textify/adapters/text.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>
+ * This file is part of Sync-in | The open source file sync and share solution
+ * See the LICENSE file for licensing details
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseText", {
+    enumerable: true,
+    get: function() {
+        return parseText;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("node:fs/promises"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function parseText(filePath) {
+    return await _promises.default.readFile(filePath, {
+        encoding: 'utf8'
+    });
+}
+
+//# sourceMappingURL=text.js.map

package/server/applications/files/utils/doc-textify/adapters/text.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../backend/src/applications/files/utils/doc-textify/adapters/text.ts"],"sourcesContent":["/*\n * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>\n * This file is part of Sync-in | The open source file sync and share solution\n * See the LICENSE file for licensing details\n */\n\nimport fs from 'fs/promises'\n\nexport async function parseText(filePath: string): Promise<string> {\n  return await fs.readFile(filePath, { encoding: 'utf8' })\n}\n"],"names":["parseText","filePath","fs","readFile","encoding"],"mappings":"AAAA;;;;CAIC;;;;+BAIqBA;;;eAAAA;;;iEAFP;;;;;;AAER,eAAeA,UAAUC,QAAgB;IAC9C,OAAO,MAAMC,iBAAE,CAACC,QAAQ,CAACF,UAAU;QAAEG,UAAU;IAAO;AACxD"}

package/server/applications/files/utils/doc-textify/adapters/word.js

@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>
+ * This file is part of Sync-in | The open source file sync and share solution
+ * See the LICENSE file for licensing details
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseWord", {
+    enumerable: true,
+    get: function() {
+        return parseWord;
+    }
+});
+const _nodeutil = require("node:util");
+const _sax = /*#__PURE__*/ _interop_require_default(require("sax"));
+const _yauzl = require("yauzl");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const openZipAsync = (0, _nodeutil.promisify)(_yauzl.open);
+async function parseWord(filePath, options) {
+    // Patterns for main document, footnotes and endnotes
+    const mainRegex = /^word\/document(?:\d*)\.xml$/;
+    const footnotesRegex = /^word\/footnotes(?:\d*)\.xml$/;
+    const endnotesRegex = /^word\/endnotes(?:\d*)\.xml$/;
+    const texts = [];
+    let hasMain = false;
+    // 1. Open the DOCX (ZIP) in lazyEntries mode
+    const zipFile = await openZipAsync(filePath, {
+        lazyEntries: true
+    });
+    return new Promise((resolve, reject)=>{
+        zipFile.readEntry();
+        zipFile.on('entry', (entry)=>{
+            const path = entry.fileName;
+            // 2. Only process document, footnotes, endnotes parts
+            if (!mainRegex.test(path) && !footnotesRegex.test(path) && !endnotesRegex.test(path)) {
+                zipFile.readEntry();
+                return;
+            }
+            if (mainRegex.test(path)) {
+                hasMain = true;
+            }
+            // 3. Open a read stream for this entry
+            zipFile.openReadStream(entry, (err, readStream)=>{
+                if (err) {
+                    zipFile.close();
+                    return reject(err);
+                }
+                // 4. SAX parser to extract <w:t> text nodes
+                const parser = _sax.default.createStream(true);
+                let buffer = '';
+                parser.on('error', (parseErr)=>{
+                    readStream.destroy();
+                    zipFile.close();
+                    reject(parseErr);
+                });
+                parser.on('opentag', (node)=>{
+                    // Start buffering when encountering a text tag
+                    if (node.name === 'w:t') {
+                        buffer = '';
+                    }
+                });
+                parser.on('text', (txt)=>{
+                    buffer += txt;
+                });
+                parser.on('closetag', (name)=>{
+                    // On closing a text tag, store its content
+                    if (name === 'w:t') {
+                        texts.push(buffer);
+                    }
+                });
+                readStream.on('error', (streamErr)=>{
+                    zipFile.close();
+                    reject(streamErr);
+                }).on('end', ()=>{
+                    // Move on to the next entry
+                    zipFile.readEntry();
+                }).pipe(parser);
+            });
+        });
+        zipFile.on('end', ()=>{
+            zipFile.close();
+            // 5. Ensure at least the main document was found
+            if (!hasMain) {
+                return reject(new Error('file seems to be corrupted'));
+            }
+            // 6. Return all collected text joined by the delimiter
+            resolve(texts.join(options.newlineDelimiter));
+        });
+        zipFile.on('error', (zipErr)=>{
+            zipFile.close();
+            reject(zipErr);
+        });
+    });
+}
+
+//# sourceMappingURL=word.js.map

package/server/applications/files/utils/doc-textify/adapters/word.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../backend/src/applications/files/utils/doc-textify/adapters/word.ts"],"sourcesContent":["/*\n * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>\n * This file is part of Sync-in | The open source file sync and share solution\n * See the LICENSE file for licensing details\n */\n\nimport { promisify } from 'node:util'\nimport sax from 'sax'\nimport { Entry, open as openZip, Options, ZipFile } from 'yauzl'\nimport { DocTextifyOptions } from '../interfaces/doc-textify.interfaces'\n\nconst openZipAsync: (path: string, options: Options) => Promise<ZipFile> = promisify(openZip)\n\n/**\n * Parses a DOCX file\n */\nexport async function parseWord(filePath: string, options: DocTextifyOptions): Promise<string> {\n  // Patterns for main document, footnotes and endnotes\n  const mainRegex = /^word\\/document(?:\\d*)\\.xml$/\n  const footnotesRegex = /^word\\/footnotes(?:\\d*)\\.xml$/\n  const endnotesRegex = /^word\\/endnotes(?:\\d*)\\.xml$/\n  const texts: string[] = []\n  let hasMain = false\n\n  // 1. Open the DOCX (ZIP) in lazyEntries mode\n  const zipFile = await openZipAsync(filePath, { lazyEntries: true })\n\n  return new Promise<string>((resolve, reject) => {\n    zipFile.readEntry()\n\n    zipFile.on('entry', (entry: Entry) => {\n      const path = entry.fileName\n\n      // 2. Only process document, footnotes, endnotes parts\n      if (!mainRegex.test(path) && !footnotesRegex.test(path) && !endnotesRegex.test(path)) {\n        zipFile.readEntry()\n        return\n      }\n\n      if (mainRegex.test(path)) {\n        hasMain = true\n      }\n\n      // 3. Open a read stream for this entry\n      zipFile.openReadStream(entry, (err, readStream) => {\n        if (err) {\n          zipFile.close()\n          return reject(err)\n        }\n\n        // 4. SAX parser to extract <w:t> text nodes\n        const parser = sax.createStream(true)\n        let buffer = ''\n\n        parser.on('error', (parseErr) => {\n          readStream.destroy()\n          zipFile.close()\n          reject(parseErr)\n        })\n\n        parser.on('opentag', (node) => {\n          // Start buffering when encountering a text tag\n          if (node.name === 'w:t') {\n            buffer = ''\n          }\n        })\n\n        parser.on('text', (txt) => {\n          buffer += txt\n        })\n\n        parser.on('closetag', (name) => {\n          // On closing a text tag, store its content\n          if (name === 'w:t') {\n            texts.push(buffer)\n          }\n        })\n\n        readStream\n          .on('error', (streamErr) => {\n            zipFile.close()\n            reject(streamErr)\n          })\n          .on('end', () => {\n            // Move on to the next entry\n            zipFile.readEntry()\n          })\n          .pipe(parser)\n      })\n    })\n\n    zipFile.on('end', () => {\n      zipFile.close()\n      // 5. Ensure at least the main document was found\n      if (!hasMain) {\n        return reject(new Error('file seems to be corrupted'))\n      }\n      // 6. Return all collected text joined by the delimiter\n      resolve(texts.join(options.newlineDelimiter))\n    })\n\n    zipFile.on('error', (zipErr) => {\n      zipFile.close()\n      reject(zipErr)\n    })\n  })\n}\n"],"names":["parseWord","openZipAsync","promisify","openZip","filePath","options","mainRegex","footnotesRegex","endnotesRegex","texts","hasMain","zipFile","lazyEntries","Promise","resolve","reject","readEntry","on","entry","path","fileName","test","openReadStream","err","readStream","close","parser","sax","createStream","buffer","parseErr","destroy","node","name","txt","push","streamErr","pipe","Error","join","newlineDelimiter","zipErr"],"mappings":"AAAA;;;;CAIC;;;;+BAYqBA;;;eAAAA;;;0BAVI;4DACV;uBACyC;;;;;;AAGzD,MAAMC,eAAqEC,IAAAA,mBAAS,EAACC,WAAO;AAKrF,eAAeH,UAAUI,QAAgB,EAAEC,OAA0B;IAC1E,qDAAqD;IACrD,MAAMC,YAAY;IAClB,MAAMC,iBAAiB;IACvB,MAAMC,gBAAgB;IACtB,MAAMC,QAAkB,EAAE;IAC1B,IAAIC,UAAU;IAEd,6CAA6C;IAC7C,MAAMC,UAAU,MAAMV,aAAaG,UAAU;QAAEQ,aAAa;IAAK;IAEjE,OAAO,IAAIC,QAAgB,CAACC,SAASC;QACnCJ,QAAQK,SAAS;QAEjBL,QAAQM,EAAE,CAAC,SAAS,CAACC;YACnB,MAAMC,OAAOD,MAAME,QAAQ;YAE3B,sDAAsD;YACtD,IAAI,CAACd,UAAUe,IAAI,CAACF,SAAS,CAACZ,eAAec,IAAI,CAACF,SAAS,CAACX,cAAca,IAAI,CAACF,OAAO;gBACpFR,QAAQK,SAAS;gBACjB;YACF;YAEA,IAAIV,UAAUe,IAAI,CAACF,OAAO;gBACxBT,UAAU;YACZ;YAEA,uCAAuC;YACvCC,QAAQW,cAAc,CAACJ,OAAO,CAACK,KAAKC;gBAClC,IAAID,KAAK;oBACPZ,QAAQc,KAAK;oBACb,OAAOV,OAAOQ;gBAChB;gBAEA,4CAA4C;gBAC5C,MAAMG,SAASC,YAAG,CAACC,YAAY,CAAC;gBAChC,IAAIC,SAAS;gBAEbH,OAAOT,EAAE,CAAC,SAAS,CAACa;oBAClBN,WAAWO,OAAO;oBAClBpB,QAAQc,KAAK;oBACbV,OAAOe;gBACT;gBAEAJ,OAAOT,EAAE,CAAC,WAAW,CAACe;oBACpB,+CAA+C;oBAC/C,IAAIA,KAAKC,IAAI,KAAK,OAAO;wBACvBJ,SAAS;oBACX;gBACF;gBAEAH,OAAOT,EAAE,CAAC,QAAQ,CAACiB;oBACjBL,UAAUK;gBACZ;gBAEAR,OAAOT,EAAE,CAAC,YAAY,CAACgB;oBACrB,2CAA2C;oBAC3C,IAAIA,SAAS,OAAO;wBAClBxB,MAAM0B,IAAI,CAACN;oBACb;gBACF;gBAEAL,WACGP,EAAE,CAAC,SAAS,CAACmB;oBACZzB,QAAQc,KAAK;oBACbV,OAAOqB;gBACT,GACCnB,EAAE,CAAC,OAAO;oBACT,4BAA4B;oBAC5BN,QAAQK,SAAS;gBACnB,GACCqB,IAAI,CAACX;YACV;QACF;QAEAf,QAAQM,EAAE,CAAC,OAAO;YAChBN,QAAQc,KAAK;YACb,iDAAiD;YACjD,IAAI,CAACf,SAAS;gBACZ,OAAOK,OAAO,IAAIuB,MAAM;YAC1B;YACA,uDAAuD;YACvDxB,QAAQL,MAAM8B,IAAI,CAAClC,QAAQmC,gBAAgB;QAC7C;QAEA7B,QAAQM,EAAE,CAAC,SAAS,CAACwB;YACnB9B,QAAQc,KAAK;YACbV,OAAO0B;QACT;IACF;AACF"}

package/server/applications/files/utils/doc-textify/doc-textify.js

@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>
+ * This file is part of Sync-in | The open source file sync and share solution
+ * See the LICENSE file for licensing details
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "docTextify", {
+    enumerable: true,
+    get: function() {
+        return docTextify;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("node:fs/promises"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _excel = require("./adapters/excel");
+const _html = require("./adapters/html");
+const _openoffice = require("./adapters/open-office");
+const _pdf = require("./adapters/pdf");
+const _powerpoint = require("./adapters/power-point");
+const _text = require("./adapters/text");
+const _word = require("./adapters/word");
+const _clean = require("./utils/clean");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function docTextify(filePath, options, fileProperties) {
+    options = {
+        newlineDelimiter: '\n',
+        minCharsToExtract: 10,
+        outputErrorToConsole: false,
+        ...options
+    };
+    if (!fileProperties?.verified) {
+        try {
+            await _promises.default.access(filePath);
+        } catch (e) {
+            throw new Error(`file does not exist or not accessible : ${filePath} (${e})`);
+        }
+    }
+    const ext = fileProperties?.extension || _nodepath.default.extname(filePath).slice(1).toLowerCase();
+    try {
+        switch(ext){
+            case 'docx':
+                return (0, _clean.cleanContent)(await (0, _word.parseWord)(filePath, options), options);
+            case 'pptx':
+                return (0, _clean.cleanContent)(await (0, _powerpoint.parsePowerPoint)(filePath, options), options);
+            case 'xlsx':
+                return (0, _clean.cleanContent)(await (0, _excel.parseExcel)(filePath, options), options);
+            case 'odt':
+            case 'odp':
+            case 'ods':
+                return (0, _clean.cleanContent)(await (0, _openoffice.parseOpenOffice)(filePath, options), options);
+            case 'pdf':
+                return (0, _clean.cleanContent)(await (0, _pdf.parsePdf)(filePath, options), options);
+            case 'txt':
+                return (0, _clean.cleanContent)(await (0, _text.parseText)(filePath), options);
+            case 'html':
+            case 'htm':
+                return (0, _clean.cleanContent)(await (0, _html.parseHtml)(filePath), options);
+            default:
+                throw new Error('currently only supports docx, pptx, xlsx, odt, odp, ods, pdf files');
+        }
+    } catch (e) {
+        if (options.outputErrorToConsole) {
+            console.error(e.message);
+        }
+        throw e;
+    }
+}
+
+//# sourceMappingURL=doc-textify.js.map

package/server/applications/files/utils/doc-textify/doc-textify.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../backend/src/applications/files/utils/doc-textify/doc-textify.ts"],"sourcesContent":["/*\n * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>\n * This file is part of Sync-in | The open source file sync and share solution\n * See the LICENSE file for licensing details\n */\n\nimport fs from 'node:fs/promises'\nimport path from 'node:path'\nimport { parseExcel } from './adapters/excel'\nimport { parseHtml } from './adapters/html'\nimport { parseOpenOffice } from './adapters/open-office'\nimport { parsePdf } from './adapters/pdf'\nimport { parsePowerPoint } from './adapters/power-point'\nimport { parseText } from './adapters/text'\nimport { parseWord } from './adapters/word'\nimport { DocTextifyOptions } from './interfaces/doc-textify.interfaces'\nimport { cleanContent } from './utils/clean'\n\n/** Main: determine parser by extension and dispatch */\nexport async function docTextify(\n  filePath: string,\n  options: DocTextifyOptions,\n  fileProperties?: { extension?: string; verified?: boolean }\n): Promise<string> {\n  options = {\n    newlineDelimiter: '\\n',\n    minCharsToExtract: 10,\n    outputErrorToConsole: false,\n    ...options\n  }\n\n  if (!fileProperties?.verified) {\n    try {\n      await fs.access(filePath)\n    } catch (e) {\n      throw new Error(`file does not exist or not accessible : ${filePath} (${e})`)\n    }\n  }\n\n  const ext = fileProperties?.extension || path.extname(filePath).slice(1).toLowerCase()\n\n  try {\n    switch (ext) {\n      case 'docx':\n        return cleanContent(await parseWord(filePath, options), options)\n      case 'pptx':\n        return cleanContent(await parsePowerPoint(filePath, options), options)\n      case 'xlsx':\n        return cleanContent(await parseExcel(filePath, options), options)\n      case 'odt':\n      case 'odp':\n      case 'ods':\n        return cleanContent(await parseOpenOffice(filePath, options), options)\n      case 'pdf':\n        return cleanContent(await parsePdf(filePath, options), options)\n      case 'txt':\n        return cleanContent(await parseText(filePath), options)\n      case 'html':\n      case 'htm':\n        return cleanContent(await parseHtml(filePath), options)\n      default:\n        throw new Error('currently only supports docx, pptx, xlsx, odt, odp, ods, pdf files')\n    }\n  } catch (e) {\n    if (options.outputErrorToConsole) {\n      console.error(e.message)\n    }\n    throw e\n  }\n}\n"],"names":["docTextify","filePath","options","fileProperties","newlineDelimiter","minCharsToExtract","outputErrorToConsole","verified","fs","access","e","Error","ext","extension","path","extname","slice","toLowerCase","cleanContent","parseWord","parsePowerPoint","parseExcel","parseOpenOffice","parsePdf","parseText","parseHtml","console","error","message"],"mappings":"AAAA;;;;CAIC;;;;+BAeqBA;;;eAAAA;;;iEAbP;iEACE;uBACU;sBACD;4BACM;qBACP;4BACO;sBACN;sBACA;uBAEG;;;;;;AAGtB,eAAeA,WACpBC,QAAgB,EAChBC,OAA0B,EAC1BC,cAA2D;IAE3DD,UAAU;QACRE,kBAAkB;QAClBC,mBAAmB;QACnBC,sBAAsB;QACtB,GAAGJ,OAAO;IACZ;IAEA,IAAI,CAACC,gBAAgBI,UAAU;QAC7B,IAAI;YACF,MAAMC,iBAAE,CAACC,MAAM,CAACR;QAClB,EAAE,OAAOS,GAAG;YACV,MAAM,IAAIC,MAAM,CAAC,wCAAwC,EAAEV,SAAS,EAAE,EAAES,EAAE,CAAC,CAAC;QAC9E;IACF;IAEA,MAAME,MAAMT,gBAAgBU,aAAaC,iBAAI,CAACC,OAAO,CAACd,UAAUe,KAAK,CAAC,GAAGC,WAAW;IAEpF,IAAI;QACF,OAAQL;YACN,KAAK;gBACH,OAAOM,IAAAA,mBAAY,EAAC,MAAMC,IAAAA,eAAS,EAAClB,UAAUC,UAAUA;YAC1D,KAAK;gBACH,OAAOgB,IAAAA,mBAAY,EAAC,MAAME,IAAAA,2BAAe,EAACnB,UAAUC,UAAUA;YAChE,KAAK;gBACH,OAAOgB,IAAAA,mBAAY,EAAC,MAAMG,IAAAA,iBAAU,EAACpB,UAAUC,UAAUA;YAC3D,KAAK;YACL,KAAK;YACL,KAAK;gBACH,OAAOgB,IAAAA,mBAAY,EAAC,MAAMI,IAAAA,2BAAe,EAACrB,UAAUC,UAAUA;YAChE,KAAK;gBACH,OAAOgB,IAAAA,mBAAY,EAAC,MAAMK,IAAAA,aAAQ,EAACtB,UAAUC,UAAUA;YACzD,KAAK;gBACH,OAAOgB,IAAAA,mBAAY,EAAC,MAAMM,IAAAA,eAAS,EAACvB,WAAWC;YACjD,KAAK;YACL,KAAK;gBACH,OAAOgB,IAAAA,mBAAY,EAAC,MAAMO,IAAAA,eAAS,EAACxB,WAAWC;YACjD;gBACE,MAAM,IAAIS,MAAM;QACpB;IACF,EAAE,OAAOD,GAAG;QACV,IAAIR,QAAQI,oBAAoB,EAAE;YAChCoB,QAAQC,KAAK,CAACjB,EAAEkB,OAAO;QACzB;QACA,MAAMlB;IACR;AACF"}

package/server/applications/files/utils/doc-textify/interfaces/doc-textify.interfaces.js

@@ -0,0 +1,10 @@
+/*
+ * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>
+ * This file is part of Sync-in | The open source file sync and share solution
+ * See the LICENSE file for licensing details
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=doc-textify.interfaces.js.map

package/server/applications/files/utils/doc-textify/interfaces/doc-textify.interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../backend/src/applications/files/utils/doc-textify/interfaces/doc-textify.interfaces.ts"],"sourcesContent":["/*\n * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>\n * This file is part of Sync-in | The open source file sync and share solution\n * See the LICENSE file for licensing details\n */\n\nexport interface DocTextifyOptions {\n  outputErrorToConsole?: boolean\n  newlineDelimiter: string\n  minCharsToExtract: number\n}\n"],"names":[],"mappings":"AAAA;;;;CAIC"}

package/server/applications/files/utils/doc-textify/utils/clean.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>
+ * This file is part of Sync-in | The open source file sync and share solution
+ * See the LICENSE file for licensing details
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "cleanContent", {
+    enumerable: true,
+    get: function() {
+        return cleanContent;
+    }
+});
+const regexAlphanumeric = /[a-zA-Z0-9]/;
+const regexpLinesAndTabs = /\r?\n|\r|\t|\u00A0/g;
+function cleanContent(content, options) {
+    if (!content || content.length <= options.minCharsToExtract) {
+        return '';
+    }
+    let result = content[0];
+    let prevChar = content[0];
+    for(let i = 1; i < content.length; i++){
+        const currentChar = content[i];
+        if (!regexAlphanumeric.test(currentChar) && currentChar === prevChar) {
+            continue;
+        }
+        result += currentChar;
+        prevChar = currentChar;
+    }
+    return result.trim().replace(regexpLinesAndTabs, options.newlineDelimiter);
+}
+
+//# sourceMappingURL=clean.js.map

package/server/applications/files/utils/doc-textify/utils/clean.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../backend/src/applications/files/utils/doc-textify/utils/clean.ts"],"sourcesContent":["/*\n * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>\n * This file is part of Sync-in | The open source file sync and share solution\n * See the LICENSE file for licensing details\n */\n\nimport { DocTextifyOptions } from '../interfaces/doc-textify.interfaces'\n\nconst regexAlphanumeric = /[a-zA-Z0-9]/\nconst regexpLinesAndTabs = /\\r?\\n|\\r|\\t|\\u00A0/g\n\nexport function cleanContent(content: string, options: DocTextifyOptions) {\n  if (!content || content.length <= options.minCharsToExtract) {\n    return ''\n  }\n\n  let result = content[0]\n  let prevChar = content[0]\n\n  for (let i = 1; i < content.length; i++) {\n    const currentChar = content[i]\n\n    if (!regexAlphanumeric.test(currentChar) && currentChar === prevChar) {\n      continue\n    }\n\n    result += currentChar\n    prevChar = currentChar\n  }\n\n  return result.trim().replace(regexpLinesAndTabs, options.newlineDelimiter)\n}\n"],"names":["cleanContent","regexAlphanumeric","regexpLinesAndTabs","content","options","length","minCharsToExtract","result","prevChar","i","currentChar","test","trim","replace","newlineDelimiter"],"mappings":"AAAA;;;;CAIC;;;;+BAOeA;;;eAAAA;;;AAHhB,MAAMC,oBAAoB;AAC1B,MAAMC,qBAAqB;AAEpB,SAASF,aAAaG,OAAe,EAAEC,OAA0B;IACtE,IAAI,CAACD,WAAWA,QAAQE,MAAM,IAAID,QAAQE,iBAAiB,EAAE;QAC3D,OAAO;IACT;IAEA,IAAIC,SAASJ,OAAO,CAAC,EAAE;IACvB,IAAIK,WAAWL,OAAO,CAAC,EAAE;IAEzB,IAAK,IAAIM,IAAI,GAAGA,IAAIN,QAAQE,MAAM,EAAEI,IAAK;QACvC,MAAMC,cAAcP,OAAO,CAACM,EAAE;QAE9B,IAAI,CAACR,kBAAkBU,IAAI,CAACD,gBAAgBA,gBAAgBF,UAAU;YACpE;QACF;QAEAD,UAAUG;QACVF,WAAWE;IACb;IAEA,OAAOH,OAAOK,IAAI,GAAGC,OAAO,CAACX,oBAAoBE,QAAQU,gBAAgB;AAC3E"}

package/server/applications/files/utils/files-search.js

@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>
+ * This file is part of Sync-in | The open source file sync and share solution
+ * See the LICENSE file for licensing details
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get MaxSortedList () {
+        return MaxSortedList;
+    },
+    get analyzeTerms () {
+        return analyzeTerms;
+    },
+    get genRegexPositiveAndNegativeTerms () {
+        return genRegexPositiveAndNegativeTerms;
+    },
+    get genTermsPattern () {
+        return genTermsPattern;
+    }
+});
+const _functions = require("../../../common/functions");
+const _indexing = require("../constants/indexing");
+const regexMatchSearchBoolean = new RegExp(`([+-]?)(?:"([^"]+)"|(\\S+))`);
+const regexMatchesSearchBoolean = new RegExp(regexMatchSearchBoolean.source, 'g');
+const booleanOperators = new Set([
+    '+',
+    '-',
+    '<',
+    '>',
+    '~',
+    '*'
+]);
+const accentToBaseMap = new Map([
+    [
+        'a',
+        '[aàáâä]'
+    ],
+    [
+        'e',
+        '[eèéêë]'
+    ],
+    [
+        'i',
+        '[iìíîï]'
+    ],
+    [
+        'o',
+        '[oòóôö]'
+    ],
+    [
+        'u',
+        '[uùúûü]'
+    ],
+    [
+        'c',
+        '[cç]'
+    ],
+    [
+        'n',
+        '[nñ]'
+    ],
+    [
+        's',
+        '[sš]'
+    ],
+    [
+        'z',
+        '[zž]'
+    ],
+    [
+        'y',
+        '[yýÿ]'
+    ]
+]);
+let MaxSortedList = class MaxSortedList {
+    insert(item) {
+        if (this.data.length === 0) {
+            this.data.push(item);
+            return;
+        }
+        // if score is smaller or the score already stored for another string ignore it and keep the first matches.
+        if (item[0] < this.data[this.data.length - 1][0] || this.data.length === this.nbItems && this.data.find(([num])=>num === item[0])) {
+            return;
+        }
+        // insert data ordered by highest score
+        const index = this.data.findIndex(([num])=>num < item[0]);
+        if (index === -1) {
+            this.data.push(item);
+        } else {
+            this.data.splice(index, 0, item);
+        }
+        // remove the smaller code
+        if (this.data.length > this.nbItems) {
+            this.data.pop();
+        }
+    }
+    constructor(nbItems){
+        this.data = [];
+        this.nbItems = nbItems;
+    }
+};
+function analyzeTerms(search, onlyAllowNegative = false) {
+    /* Get the positive or negative terms list */ const matches = search.match(regexMatchesSearchBoolean) || [];
+    if (!matches.length) {
+        return matches;
+    }
+    return matches.flatMap((match)=>{
+        const [, operator, quoted, unquoted] = match.match(regexMatchSearchBoolean);
+        let term = (quoted || unquoted).trim();
+        if (term.length < _indexing.minCharsToSearch) return null;
+        if (onlyAllowNegative && operator !== '-' || !onlyAllowNegative && (operator === '-' || operator === '~')) return null;
+        if (booleanOperators.has(term[0])) {
+            term = term.substring(1);
+        }
+        if (term[term.length - 1] === '*') {
+            term = term.substring(0, term.length - 1);
+        }
+        return (0, _functions.escapeString)(term);
+    }).filter(Boolean);
+}
+function genTermsPattern(terms) {
+    return terms.map((t)=>genAccentInsensitiveRegexpPattern(t)).join('|');
+}
+function genRegexPositiveAndNegativeTerms(search) {
+    const positiveTerms = analyzeTerms(search);
+    const negativeTerms = analyzeTerms(search, true);
+    const p = positiveTerms.map((t)=>genAccentInsensitiveRegexpPattern(t)).map((t)=>`(?=.*\\b${t})`).join('');
+    if (!negativeTerms.length) return new RegExp(p, 'i');
+    const n = negativeTerms.map((t)=>genAccentInsensitiveRegexpPattern(t)).map((t)=>`\\b${t}\\b`).join('|');
+    return new RegExp(`^${p}(?!.*(${n})).*$`, 'i');
+}
+function genAccentInsensitiveRegexpPattern(input) {
+    /* Allow to catch all terms with accents or not */ return input.split('').map((char)=>accentToBaseMap.get(char) || char).join('');
+}
+
+//# sourceMappingURL=files-search.js.map