@qe-mcp/ena 0.0.0-stage → 0.1.18

package/xlsx.js

@@ -0,0 +1,181 @@
+/**
+ * xlsx.js — read the first worksheet of an .xlsx file as CSV text, as the ENA
+ * Web Tool does for an uploaded .xlsx (rENA-webtool js/XlsxReader.js, ported
+ * to Node: zlib instead of JSZip, a small XML reader instead of the browser's
+ * DOMParser).
+ *
+ * Parity with the web tool, and so with R's openxlsx::read.xlsx(sheet = 1):
+ *   - first sheet in tab order only; its first row is the header row
+ *   - values as stored: dates stay Excel serial numbers (no date detection)
+ *   - booleans as TRUE / FALSE; shared and inline strings resolved
+ *   - rows are taken in file order and padded to the widest row
+ */
+
+import { inflateRawSync } from 'zlib';
+
+// ── ZIP: the entries of an .xlsx (a ZIP of XML parts) ────────────────────────
+function unzip(buf) {
+    // End of central directory: scan back over a possible archive comment.
+    let eocd = -1;
+    for (let i = buf.length - 22; i >= Math.max(0, buf.length - 65557); i--)
+        if (buf.readUInt32LE(i) === 0x06054b50) { eocd = i; break; }
+    if (eocd < 0) throw new Error('not an .xlsx file (no ZIP directory found)');
+    const count = buf.readUInt16LE(eocd + 10);
+    let p = buf.readUInt32LE(eocd + 16);
+    const files = new Map();
+    for (let n = 0; n < count; n++) {
+        if (buf.readUInt32LE(p) !== 0x02014b50) throw new Error('corrupt .xlsx (bad ZIP directory)');
+        const method = buf.readUInt16LE(p + 10);
+        const size = buf.readUInt32LE(p + 20);
+        const nameLen = buf.readUInt16LE(p + 28), extraLen = buf.readUInt16LE(p + 30), commentLen = buf.readUInt16LE(p + 32);
+        const local = buf.readUInt32LE(p + 42);
+        const name = buf.toString('utf8', p + 46, p + 46 + nameLen);
+        p += 46 + nameLen + extraLen + commentLen;
+        files.set(name, () => {
+            const start = local + 30 + buf.readUInt16LE(local + 26) + buf.readUInt16LE(local + 28);
+            const data = buf.subarray(start, start + size);
+            if (method === 0) return data;
+            if (method === 8) return inflateRawSync(data);
+            throw new Error(`unsupported compression in .xlsx entry ${name}`);
+        });
+    }
+    return { file: (name) => files.get(name)?.() ?? null };
+}
+
+// ── XML: the little of it that SpreadsheetML needs ───────────────────────────
+// Elements with getElementsByTagName (descendants, local name), getAttribute
+// (prefixed or not) and textContent — the subset the readers below use. No
+// namespaces, DTDs or entities beyond the five predefined and numeric ones.
+const XML_ENTITIES = { lt: '<', gt: '>', amp: '&', quot: '"', apos: "'" };
+const unescapeXml = (s) => s.indexOf('&') < 0 ? s : s.replace(/&(#x[0-9a-fA-F]+|#\d+|\w+);/g, (m, e) =>
+    e[0] === '#' ? String.fromCodePoint(e[1] === 'x' ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10))
+                 : (XML_ENTITIES[e] ?? m));
+
+class XmlElement {
+    constructor(name, attrs) { this.name = name; this.attrs = attrs; this.children = []; }
+    get localName() { const i = this.name.indexOf(':'); return i < 0 ? this.name : this.name.slice(i + 1); }
+    getAttribute(name) {
+        if (name in this.attrs) return this.attrs[name];
+        const i = name.indexOf(':');                       // "r:id" also matches an unprefixed "id"
+        return i >= 0 && name.slice(i + 1) in this.attrs ? this.attrs[name.slice(i + 1)] : null;
+    }
+    getAttributeNS(ns, local) {
+        for (const k in this.attrs) if (k === local || k.endsWith(':' + local)) return this.attrs[k];
+        return null;
+    }
+    get textContent() {
+        let out = '';
+        for (const c of this.children) out += typeof c === 'string' ? c : c.textContent;
+        return out;
+    }
+    getElementsByTagName(local) {
+        const out = [];
+        const walk = (el) => { for (const c of el.children) if (typeof c !== 'string') { if (c.localName === local) out.push(c); walk(c); } };
+        walk(this);
+        return out;
+    }
+}
+
+const ATTR_RE = /([^\s=\/>]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+function parseXml(buf) {
+    const xml = buf.toString('utf8');
+    const root = new XmlElement('#document', {});
+    const stack = [root];
+    const TAG_RE = /<(\/)?([^\s\/>!?]+)([^>]*?)(\/)?>|<!\[CDATA\[([\s\S]*?)\]\]>|<!--[\s\S]*?-->|<[!?][^>]*>/g;
+    let last = 0, m;
+    while ((m = TAG_RE.exec(xml))) {
+        const text = xml.slice(last, m.index);
+        if (text) stack[stack.length - 1].children.push(unescapeXml(text));
+        last = TAG_RE.lastIndex;
+        if (m[5] !== undefined) { stack[stack.length - 1].children.push(m[5]); continue; }   // CDATA
+        if (m[2] === undefined) continue;                                                     // comment, PI, doctype
+        if (m[1]) { if (stack.length > 1) stack.pop(); continue; }                            // closing tag
+        const attrs = {};
+        for (const a of m[3].matchAll(ATTR_RE)) attrs[a[1]] = unescapeXml(a[2] ?? a[3] ?? '');
+        const el = new XmlElement(m[2], attrs);
+        stack[stack.length - 1].children.push(el);
+        if (!m[4]) stack.push(el);
+    }
+    return root;
+}
+
+// "A1" / "BC12" → 0-based column. Column letters are base-26 (bijective).
+function refCol(ref) {
+    let col = 0;
+    for (let i = 0; i < ref.length; i++) {
+        const ch = ref.charCodeAt(i);
+        if (ch < 65 || ch > 90) break;
+        col = col * 26 + (ch - 64);
+    }
+    return col - 1;
+}
+
+// Text of a shared-string <si> or inline <is> (rich-text runs concatenated).
+function textOf(elem) {
+    if (!elem) return '';
+    let out = '';
+    for (const t of elem.getElementsByTagName('t')) out += t.textContent;
+    return out;
+}
+
+function firstSheetPath(zip) {
+    const wb = zip.file('xl/workbook.xml');
+    if (!wb) throw new Error('not an .xlsx workbook (xl/workbook.xml missing)');
+    const sheets = parseXml(wb).getElementsByTagName('sheet');
+    if (!sheets.length) throw new Error('the workbook has no sheets');
+    const rid = sheets[0].getAttribute('r:id')
+        || sheets[0].getAttributeNS('http://schemas.openxmlformats.org/officeDocument/2006/relationships', 'id');
+    const rels = zip.file('xl/_rels/workbook.xml.rels');
+    if (rels) {
+        for (const rel of parseXml(rels).getElementsByTagName('Relationship')) {
+            if (rel.getAttribute('Id') !== rid) continue;
+            const target = rel.getAttribute('Target');
+            if (target.charAt(0) === '/') return target.slice(1);
+            return target.indexOf('xl/') === 0 ? target : 'xl/' + target;
+        }
+    }
+    return 'xl/worksheets/sheet1.xml';
+}
+
+function csvField(v) {
+    if (v == null) return '';
+    const s = String(v);
+    return /[",\r\n]/.test(s) ? '"' + s.replace(/"/g, '""') + '"' : s;
+}
+
+function cellValue(cell, shared) {
+    const t = cell.getAttribute('t');           // s | inlineStr | str | b | e | n | (none)
+    if (t === 'inlineStr') return textOf(cell.getElementsByTagName('is')[0]);
+    const v = cell.getElementsByTagName('v')[0];
+    const raw = v ? v.textContent : '';
+    if (t === 's') return shared[parseInt(raw, 10)] || '';
+    if (t === 'b') return raw === '1' ? 'TRUE' : 'FALSE';
+    return raw;
+}
+
+/** CSV text of the first worksheet of the .xlsx in buf. */
+export function xlsxToCSV(buf) {
+    const zip = unzip(buf);
+    const sst = zip.file('xl/sharedStrings.xml');
+    const shared = sst ? Array.from(parseXml(sst).getElementsByTagName('si'), textOf) : [];
+    const path = firstSheetPath(zip);
+    const sheet = zip.file(path);
+    if (!sheet) throw new Error(`worksheet not found: ${path}`);
+
+    const grid = [];
+    let maxCol = -1;
+    for (const rowEl of parseXml(sheet).getElementsByTagName('row')) {
+        const row = [];
+        Array.from(rowEl.getElementsByTagName('c')).forEach((cell, c) => {
+            const ref = cell.getAttribute('r');
+            const col = ref ? refCol(ref) : c;
+            row[col] = cellValue(cell, shared);
+            if (col > maxCol) maxCol = col;
+        });
+        grid.push(row);
+    }
+    if (maxCol < 0) return '';
+    return grid.map(row => Array.from({ length: maxCol + 1 }, (_, c) => csvField(row[c])).join(',')).join('\r\n');
+}
+
+export const isXlsx = (path) => /\.xlsx$/i.test(String(path ?? ''));