@yeyuan98/opencode-bioresearcher-plugin 1.7.0 → 1.7.1

package/dist/tools/table/backends/csv/index.js

@@ -0,0 +1,660 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { BaseTableBackend } from '../base';
+import { iterativeMin, iterativeMax, DEFAULT_MAX_RANGE_CELLS } from '../../utils';
+const CELL_ADDRESS_REGEX = /^[A-Za-z]+\d+$/;
+function coerceCSVValue(field) {
+    if (field === '')
+        return undefined;
+    const num = Number(field);
+    if (!isNaN(num) && field.trim() !== '')
+        return num;
+    return field;
+}
+function deduplicateHeaders(rawHeaders) {
+    const headers = [];
+    const seen = new Map();
+    for (const raw of rawHeaders) {
+        const count = seen.get(raw) ?? 0;
+        seen.set(raw, count + 1);
+        headers.push(count > 0 ? `${raw}_${count}` : raw);
+    }
+    return headers;
+}
+function detectDelimiter(resolvedPath) {
+    const ext = path.extname(resolvedPath).toLowerCase();
+    if (ext === '.tsv')
+        return '\t';
+    if (ext === '.csv')
+        return ',';
+    const firstLine = fs.readFileSync(resolvedPath, 'utf-8').split('\n')[0] || '';
+    const commas = (firstLine.match(/,/g) || []).length;
+    const tabs = (firstLine.match(/\t/g) || []).length;
+    return tabs > commas ? '\t' : ',';
+}
+function parseCSVLine(line, delimiter) {
+    const fields = [];
+    let current = '';
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (inQuotes) {
+            if (ch === '"') {
+                if (i + 1 < line.length && line[i + 1] === '"') {
+                    current += '"';
+                    i++;
+                }
+                else {
+                    inQuotes = false;
+                }
+            }
+            else {
+                current += ch;
+            }
+        }
+        else {
+            if (ch === '"') {
+                inQuotes = true;
+            }
+            else if (ch === delimiter) {
+                fields.push(current);
+                current = '';
+            }
+            else {
+                current += ch;
+            }
+        }
+    }
+    fields.push(current);
+    return fields;
+}
+function rowFieldsToObject(fields, headers) {
+    const obj = {};
+    for (let i = 0; i < headers.length; i++) {
+        const val = coerceCSVValue(fields[i] ?? '');
+        if (val !== undefined) {
+            obj[headers[i]] = val;
+        }
+    }
+    return obj;
+}
+function encodeColumn(col) {
+    let result = '';
+    let c = col;
+    while (c >= 0) {
+        result = String.fromCharCode(65 + (c % 26)) + result;
+        c = Math.floor(c / 26) - 1;
+    }
+    return result;
+}
+function decodeColumn(str) {
+    let col = 0;
+    for (let i = 0; i < str.length; i++) {
+        col = col * 26 + (str.charCodeAt(i) - 64);
+    }
+    return col - 1;
+}
+function decodeCellAddress(address) {
+    const match = address.match(/^([A-Za-z]+)(\d+)$/);
+    if (!match)
+        throw new Error(`Invalid cell address: ${address}`);
+    return { col: decodeColumn(match[1].toUpperCase()), row: parseInt(match[2], 10) - 1 };
+}
+function escapeCSVField(field, delimiter) {
+    const str = String(field ?? '');
+    if (str.includes(delimiter) || str.includes('"') || str.includes('\n') || str.includes('\r')) {
+        return '"' + str.replace(/"/g, '""') + '"';
+    }
+    return str;
+}
+export class CSVBackend extends BaseTableBackend {
+    type = 'csv';
+    delimiter;
+    _headers = null;
+    _totalDataRows = null;
+    constructor(resolvedPath, force) {
+        super(resolvedPath, force);
+        this.delimiter = detectDelimiter(resolvedPath);
+    }
+    readHeaders() {
+        if (this._headers)
+            return this._headers;
+        const firstLine = fs.readFileSync(this.resolvedPath, 'utf-8').split('\n')[0] || '';
+        const rawHeaders = parseCSVLine(firstLine, this.delimiter);
+        const processed = rawHeaders.map((h, i) => {
+            const trimmed = h.trim();
+            return (trimmed !== '') ? trimmed : `Column_${i}`;
+        });
+        this._headers = deduplicateHeaders(processed);
+        return this._headers;
+    }
+    countDataRows() {
+        if (this._totalDataRows !== null)
+            return this._totalDataRows;
+        const content = fs.readFileSync(this.resolvedPath, 'utf-8');
+        const lines = content.split('\n');
+        let count = 0;
+        for (let i = 1; i < lines.length; i++) {
+            if (lines[i].trim() === '' && i === lines.length - 1)
+                continue;
+            if (lines[i].trim() === '')
+                continue;
+            count++;
+        }
+        this._totalDataRows = count;
+        return this._totalDataRows;
+    }
+    listSheets() {
+        return [{ name: 'Sheet1', index: 0 }];
+    }
+    getHeaders(sheetIndex) {
+        this.ensureSheetIndex(sheetIndex);
+        const headers = this.readHeaders();
+        return { headers, columnCount: headers.length };
+    }
+    getTotalDataRows(sheetIndex) {
+        this.ensureSheetIndex(sheetIndex);
+        return this.countDataRows();
+    }
+    getCell(sheetIndex, cellAddress) {
+        this.ensureSheetIndex(sheetIndex);
+        if (!CELL_ADDRESS_REGEX.test(cellAddress)) {
+            throw new Error(`Invalid cell address "${cellAddress}". Expected format like "A1", "B5", "AA123".`);
+        }
+        const { row, col } = decodeCellAddress(cellAddress);
+        const headers = this.readHeaders();
+        const content = fs.readFileSync(this.resolvedPath, 'utf-8');
+        const lines = content.split('\n');
+        if (row < 0 || row >= lines.length)
+            return { value: '', type: 'unknown' };
+        const targetLine = lines[row];
+        if (!targetLine && row > 0)
+            return { value: '', type: 'unknown' };
+        const fields = parseCSVLine(targetLine || lines[0], this.delimiter);
+        const fieldVal = fields[col];
+        if (fieldVal === undefined)
+            return { value: '', type: 'unknown' };
+        if (row === 0)
+            return { value: fieldVal.trim(), type: 's' };
+        const coerced = coerceCSVValue(fieldVal);
+        return { value: coerced ?? '', type: typeof coerced === 'number' ? 'n' : 's' };
+    }
+    getRange(sheetIndex, range) {
+        this.ensureSheetIndex(sheetIndex);
+        const { s, e } = (() => {
+            const parts = range.split(':');
+            const start = decodeCellAddress(parts[0]);
+            const end = parts[1] ? decodeCellAddress(parts[1]) : { ...start };
+            return {
+                s: { r: start.row, c: start.col },
+                e: { r: end.row, c: end.col },
+            };
+        })();
+        const requestedCells = (e.r - s.r + 1) * (e.c - s.c + 1);
+        if (!this.force && requestedCells > DEFAULT_MAX_RANGE_CELLS) {
+            throw new Error(`Range "${range}" exceeds ${DEFAULT_MAX_RANGE_CELLS} cell limit (${requestedCells} cells). Set force: true to override.`);
+        }
+        const headers = this.readHeaders();
+        const totalCols = headers.length;
+        const totalRows = this.countDataRows() + 1;
+        const clampedS = { r: Math.max(s.r, 0), c: Math.max(s.c, 0) };
+        const clampedE = { r: Math.min(e.r, totalRows - 1), c: Math.min(e.c, totalCols - 1) };
+        if (clampedS.r > clampedE.r || clampedS.c > clampedE.c) {
+            return { data: [], rows: 0, columns: 0, out_of_bounds: true };
+        }
+        const content = fs.readFileSync(this.resolvedPath, 'utf-8');
+        const lines = content.split('\n');
+        const data = [];
+        for (let r = clampedS.r; r <= clampedE.r; r++) {
+            const line = lines[r];
+            if (!line) {
+                data.push(new Array(clampedE.c - clampedS.c + 1).fill(''));
+                continue;
+            }
+            const fields = parseCSVLine(line, this.delimiter);
+            const row = [];
+            for (let c = clampedS.c; c <= clampedE.c; c++) {
+                const fieldVal = fields[c];
+                if (r === 0) {
+                    row.push(fieldVal?.trim() ?? '');
+                }
+                else {
+                    const coerced = fieldVal !== undefined ? coerceCSVValue(fieldVal) : '';
+                    row.push(coerced ?? '');
+                }
+            }
+            data.push(row);
+        }
+        const result = { data, rows: data.length, columns: data[0]?.length || 0 };
+        if (clampedS.r !== s.r || clampedS.c !== s.c || clampedE.r !== e.r || clampedE.c !== e.c) {
+            result.clamped_to = `${encodeColumn(clampedS.c)}${clampedS.r + 1}:${encodeColumn(clampedE.c)}${clampedE.r + 1}`;
+        }
+        return result;
+    }
+    getPreview(sheetIndex, maxRows) {
+        this.ensureSheetIndex(sheetIndex);
+        const headers = this.readHeaders();
+        const content = fs.readFileSync(this.resolvedPath, 'utf-8');
+        const lines = content.split('\n');
+        const previewRows = [];
+        const headerRow = headers.map(h => h);
+        previewRows.push(headerRow);
+        for (let i = 1; i < lines.length && previewRows.length < maxRows; i++) {
+            const line = lines[i];
+            if (line.trim() === '' && i === lines.length - 1)
+                continue;
+            if (line.trim() === '')
+                continue;
+            const fields = parseCSVLine(line, this.delimiter);
+            const row = headers.map((_, ci) => {
+                const val = coerceCSVValue(fields[ci] ?? '');
+                return val ?? '';
+            });
+            previewRows.push(row);
+        }
+        return { rows: previewRows, totalRows: this.countDataRows() + 1 };
+    }
+    search(sheetIndex, searchTerm, options) {
+        this.ensureSheetIndex(sheetIndex);
+        const headers = this.readHeaders();
+        const results = [];
+        let totalMatchesFound = 0;
+        let rowsScanned = 0;
+        const term = searchTerm.toLowerCase();
+        let searchColIdx = null;
+        if (options.column) {
+            searchColIdx = headers.indexOf(options.column);
+            if (searchColIdx === -1) {
+                throw new Error(`Column "${options.column}" not found. Available columns: ${headers.slice(0, 20).join(', ')}${headers.length > 20 ? ` ... (${headers.length} total)` : ''}`);
+            }
+        }
+        const content = fs.readFileSync(this.resolvedPath, 'utf-8');
+        const lines = content.split('\n');
+        let dataRowIdx = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.trim() === '' && i === lines.length - 1)
+                continue;
+            if (line.trim() === '' && i > 0)
+                continue;
+            rowsScanned++;
+            if (rowsScanned > options.maxRowsScan + 1)
+                break;
+            const fields = parseCSVLine(line, this.delimiter);
+            if (searchColIdx !== null) {
+                const fieldVal = fields[searchColIdx] ?? '';
+                if (String(fieldVal).toLowerCase().includes(term)) {
+                    totalMatchesFound++;
+                    if (results.length < options.maxResults) {
+                        const address = `${encodeColumn(searchColIdx)}${i + 1}`;
+                        const coerced = coerceCSVValue(fieldVal);
+                        results.push({ address, value: coerced ?? fieldVal, type: typeof coerced === 'number' ? 'n' : 's', row_index: i, column: options.column });
+                    }
+                }
+            }
+            else {
+                for (let c = 0; c < fields.length; c++) {
+                    const fieldVal = fields[c] ?? '';
+                    if (String(fieldVal).toLowerCase().includes(term)) {
+                        totalMatchesFound++;
+                        if (results.length < options.maxResults) {
+                            const address = `${encodeColumn(c)}${i + 1}`;
+                            const coerced = coerceCSVValue(fieldVal);
+                            results.push({ address, value: coerced ?? fieldVal, type: typeof coerced === 'number' ? 'n' : 's', row_index: i });
+                        }
+                    }
+                }
+            }
+        }
+        return { results, totalMatchesFound, rowsScanned };
+    }
+    filterRows(sheetIndex, column, operator, value, options) {
+        this.ensureSheetIndex(sheetIndex);
+        const headers = this.readHeaders();
+        const filterColIdx = headers.indexOf(column);
+        if (filterColIdx === -1) {
+            throw new Error(`Column "${column}" not found. Available columns: ${headers.slice(0, 20).join(', ')}${headers.length > 20 ? ` ... (${headers.length} total)` : ''}`);
+        }
+        const filteredRows = [];
+        let totalMatchesFound = 0;
+        const content = fs.readFileSync(this.resolvedPath, 'utf-8');
+        const lines = content.split('\n');
+        let scanned = 0;
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.trim() === '' && i === lines.length - 1)
+                continue;
+            if (line.trim() === '')
+                continue;
+            scanned++;
+            if (scanned > options.maxRowsScan)
+                break;
+            const fields = parseCSVLine(line, this.delimiter);
+            let cellValue = coerceCSVValue(fields[filterColIdx] ?? '');
+            if (cellValue === undefined)
+                cellValue = '';
+            let normalizedCell = cellValue;
+            let normalizedComp = value;
+            if (typeof normalizedCell === 'string' && normalizedCell.trim() !== '' && !isNaN(Number(normalizedCell))) {
+                normalizedCell = Number(normalizedCell);
+            }
+            if (typeof normalizedComp === 'string' && normalizedComp.trim() !== '' && !isNaN(Number(normalizedComp))) {
+                normalizedComp = Number(normalizedComp);
+            }
+            let matches = false;
+            switch (operator) {
+                case '=':
+                    matches = normalizedCell === normalizedComp;
+                    break;
+                case '!=':
+                    matches = normalizedCell !== normalizedComp;
+                    break;
+                case '>':
+                    matches = normalizedCell > normalizedComp;
+                    break;
+                case '<':
+                    matches = normalizedCell < normalizedComp;
+                    break;
+                case '>=':
+                    matches = normalizedCell >= normalizedComp;
+                    break;
+                case '<=':
+                    matches = normalizedCell <= normalizedComp;
+                    break;
+                case 'contains':
+                    matches = String(normalizedCell).toLowerCase().includes(String(normalizedComp).toLowerCase());
+                    break;
+                case 'starts_with':
+                    matches = String(normalizedCell).toLowerCase().startsWith(String(normalizedComp).toLowerCase());
+                    break;
+                case 'ends_with':
+                    matches = String(normalizedCell).toLowerCase().endsWith(String(normalizedComp).toLowerCase());
+                    break;
+            }
+            if (matches) {
+                totalMatchesFound++;
+                if (filteredRows.length < options.maxResults) {
+                    filteredRows.push(rowFieldsToObject(fields, headers));
+                }
+            }
+        }
+        return {
+            matchedRows: filteredRows,
+            totalMatchesFound,
+            totalDataRows: this.countDataRows(),
+        };
+    }
+    summarize(sheetIndex, columns, options) {
+        this.ensureSheetIndex(sheetIndex);
+        const headers = this.readHeaders();
+        const columnsToAnalyze = columns && columns.length > 0 ? columns : headers;
+        const colStats = new Map();
+        for (const col of columnsToAnalyze) {
+            colStats.set(col, { n: 0, mean: 0, m2: 0, min: Infinity, max: -Infinity, sum: 0 });
+        }
+        const content = fs.readFileSync(this.resolvedPath, 'utf-8');
+        const lines = content.split('\n');
+        let scanned = 0;
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.trim() === '' && i === lines.length - 1)
+                continue;
+            if (line.trim() === '')
+                continue;
+            scanned++;
+            if (scanned > options.maxRowsScan)
+                break;
+            const fields = parseCSVLine(line, this.delimiter);
+            for (let ci = 0; ci < columnsToAnalyze.length; ci++) {
+                const colName = columnsToAnalyze[ci];
+                const colIdx = headers.indexOf(colName);
+                if (colIdx === -1)
+                    continue;
+                const val = coerceCSVValue(fields[colIdx] ?? '');
+                if (typeof val !== 'number' || isNaN(val))
+                    continue;
+                const s = colStats.get(colName);
+                s.n++;
+                s.sum += val;
+                if (val < s.min)
+                    s.min = val;
+                if (val > s.max)
+                    s.max = val;
+                const delta = val - s.mean;
+                s.mean += delta / s.n;
+                const delta2 = val - s.mean;
+                s.m2 += delta * delta2;
+            }
+        }
+        const summaries = {};
+        for (const col of columnsToAnalyze) {
+            const s = colStats.get(col);
+            if (s.n > 0) {
+                summaries[col] = { sum: s.sum, avg: s.mean, min: s.min, max: s.max, std_dev: Math.sqrt(s.m2 / s.n) };
+            }
+        }
+        return { summaries, rowCount: scanned };
+    }
+    groupBy(sheetIndex, groupColumn, aggColumn, aggType, options) {
+        this.ensureSheetIndex(sheetIndex);
+        const headers = this.readHeaders();
+        const groupColIdx = headers.indexOf(groupColumn);
+        const aggColIdx = headers.indexOf(aggColumn);
+        if (groupColIdx === -1)
+            throw new Error(`Group column "${groupColumn}" not found`);
+        if (aggColIdx === -1)
+            throw new Error(`Aggregation column "${aggColumn}" not found`);
+        const grouped = {};
+        const content = fs.readFileSync(this.resolvedPath, 'utf-8');
+        const lines = content.split('\n');
+        let scanned = 0;
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.trim() === '' && i === lines.length - 1)
+                continue;
+            if (line.trim() === '')
+                continue;
+            scanned++;
+            if (scanned > options.maxRowsScan)
+                break;
+            const fields = parseCSVLine(line, this.delimiter);
+            const groupKey = String(coerceCSVValue(fields[groupColIdx] ?? '') || '');
+            const aggValue = coerceCSVValue(fields[aggColIdx] ?? '');
+            if (!grouped[groupKey])
+                grouped[groupKey] = [];
+            if (aggType === 'count') {
+                grouped[groupKey].push(1);
+            }
+            else if (typeof aggValue === 'number' && !isNaN(aggValue)) {
+                grouped[groupKey].push(aggValue);
+            }
+        }
+        const result = {};
+        for (const groupKey of Object.keys(grouped)) {
+            const values = grouped[groupKey];
+            if (values.length === 0) {
+                result[groupKey] = 0;
+                continue;
+            }
+            switch (aggType) {
+                case 'sum':
+                    result[groupKey] = values.reduce((a, b) => a + b, 0);
+                    break;
+                case 'count':
+                    result[groupKey] = values.length;
+                    break;
+                case 'avg':
+                    result[groupKey] = values.reduce((a, b) => a + b, 0) / values.length;
+                    break;
+                case 'min': {
+                    const m = iterativeMin(values);
+                    result[groupKey] = m !== undefined ? m : 0;
+                    break;
+                }
+                case 'max': {
+                    const m = iterativeMax(values);
+                    result[groupKey] = m !== undefined ? m : 0;
+                    break;
+                }
+            }
+        }
+        return { groups: result };
+    }
+    pivotSummary(sheetIndex, rowField, colField, valueField, agg, options) {
+        this.ensureSheetIndex(sheetIndex);
+        const headers = this.readHeaders();
+        const rowFieldIdx = headers.indexOf(rowField);
+        const colFieldIdx = headers.indexOf(colField);
+        const valueFieldIdx = headers.indexOf(valueField);
+        if (rowFieldIdx === -1)
+            throw new Error(`Row field "${rowField}" not found`);
+        if (colFieldIdx === -1)
+            throw new Error(`Column field "${colField}" not found`);
+        if (valueFieldIdx === -1)
+            throw new Error(`Value field "${valueField}" not found`);
+        const pivot = {};
+        const counts = {};
+        const allCols = new Set();
+        const content = fs.readFileSync(this.resolvedPath, 'utf-8');
+        const lines = content.split('\n');
+        let scanned = 0;
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.trim() === '' && i === lines.length - 1)
+                continue;
+            if (line.trim() === '')
+                continue;
+            scanned++;
+            if (scanned > options.maxRowsScan)
+                break;
+            const fields = parseCSVLine(line, this.delimiter);
+            const rowKey = String(coerceCSVValue(fields[rowFieldIdx] ?? '') || '');
+            const colKey = String(coerceCSVValue(fields[colFieldIdx] ?? '') || '');
+            const value = coerceCSVValue(fields[valueFieldIdx] ?? '');
+            allCols.add(colKey);
+            const isNumeric = typeof value === 'number' && !isNaN(value);
+            if (!isNumeric)
+                continue;
+            if (!pivot[rowKey])
+                pivot[rowKey] = {};
+            if (!counts[rowKey])
+                counts[rowKey] = {};
+            if (!pivot[rowKey][colKey]) {
+                if (agg === 'min')
+                    pivot[rowKey][colKey] = Infinity;
+                else if (agg === 'max')
+                    pivot[rowKey][colKey] = -Infinity;
+                else
+                    pivot[rowKey][colKey] = 0;
+            }
+            if (!counts[rowKey][colKey])
+                counts[rowKey][colKey] = 0;
+            counts[rowKey][colKey]++;
+            switch (agg) {
+                case 'sum':
+                case 'avg':
+                    pivot[rowKey][colKey] += value;
+                    break;
+                case 'min':
+                    pivot[rowKey][colKey] = Math.min(pivot[rowKey][colKey], value);
+                    break;
+                case 'max':
+                    pivot[rowKey][colKey] = Math.max(pivot[rowKey][colKey], value);
+                    break;
+                case 'count':
+                    pivot[rowKey][colKey]++;
+                    break;
+            }
+        }
+        if (agg === 'avg') {
+            for (const rowKey of Object.keys(pivot)) {
+                for (const colKey of Object.keys(pivot[rowKey])) {
+                    const count = counts[rowKey][colKey];
+                    if (count > 0)
+                        pivot[rowKey][colKey] /= count;
+                }
+            }
+        }
+        return { columns: Array.from(allCols).sort(), pivot };
+    }
+    appendRows(sheetIndex, rows) {
+        this.ensureSheetIndex(sheetIndex);
+        const headers = this.readHeaders();
+        const lines = [];
+        for (const row of rows) {
+            if (Array.isArray(row)) {
+                lines.push(row.map((v) => escapeCSVField(v, this.delimiter)).join(this.delimiter));
+            }
+            else {
+                const fields = headers.map(h => escapeCSVField(row[h] ?? '', this.delimiter));
+                lines.push(fields.join(this.delimiter));
+            }
+        }
+        fs.appendFileSync(this.resolvedPath, '\n' + lines.join('\n'));
+        this._totalDataRows = null;
+    }
+    updateCell(sheetIndex, cellAddress, value) {
+        this.ensureSheetIndex(sheetIndex);
+        if (!CELL_ADDRESS_REGEX.test(cellAddress)) {
+            throw new Error(`Invalid cell address "${cellAddress}". Expected format like "A1", "B5", "AA123".`);
+        }
+        const { row, col } = decodeCellAddress(cellAddress);
+        const content = fs.readFileSync(this.resolvedPath, 'utf-8');
+        const lines = content.split('\n');
+        while (lines.length <= row)
+            lines.push('');
+        const targetLine = lines[row];
+        const fields = parseCSVLine(targetLine, this.delimiter);
+        while (fields.length <= col)
+            fields.push('');
+        if (value === null) {
+            fields[col] = '';
+        }
+        else {
+            fields[col] = String(value);
+        }
+        lines[row] = fields.map(f => escapeCSVField(f, this.delimiter)).join(this.delimiter);
+        const suffix = crypto.randomBytes(8).toString('hex');
+        const tmpPath = this.resolvedPath + `.tmp_${suffix}`;
+        fs.writeFileSync(tmpPath, lines.join('\n'));
+        fs.renameSync(tmpPath, this.resolvedPath);
+        this._headers = null;
+        this._totalDataRows = null;
+    }
+    createFile(sheetName, data) {
+        let parsedData = data;
+        if (typeof parsedData === 'string') {
+            try {
+                parsedData = JSON.parse(parsedData);
+            }
+            catch (e) {
+                throw new Error(`Failed to parse data string as JSON: ${e}`);
+            }
+        }
+        if (!Array.isArray(parsedData))
+            throw new Error(`Data must be an array, received: ${typeof parsedData}`);
+        const lines = [];
+        if (parsedData.length > 0) {
+            if (Array.isArray(parsedData[0])) {
+                for (const row of parsedData) {
+                    lines.push(row.map((v) => escapeCSVField(v, this.delimiter)).join(this.delimiter));
+                }
+            }
+            else {
+                const keys = Object.keys(parsedData[0]);
+                lines.push(keys.map(k => escapeCSVField(k, this.delimiter)).join(this.delimiter));
+                for (const row of parsedData) {
+                    lines.push(keys.map(k => escapeCSVField(row[k], this.delimiter)).join(this.delimiter));
+                }
+            }
+        }
+        fs.writeFileSync(this.resolvedPath, lines.join('\n'));
+        this._headers = null;
+        this._totalDataRows = null;
+    }
+    dispose() {
+        this._headers = null;
+        this._totalDataRows = null;
+    }
+}

package/dist/tools/table/backends/factory.d.ts

@@ -0,0 +1,2 @@
+import type { IWritableTableBackend } from './interface';
+export declare function createBackend(resolvedPath: string, force: boolean): IWritableTableBackend;

package/dist/tools/table/backends/factory.js

@@ -0,0 +1,14 @@
+import * as path from 'path';
+import { XLSXBackend } from './xlsx';
+import { CSVBackend } from './csv';
+export function createBackend(resolvedPath, force) {
+    const ext = path.extname(resolvedPath).toLowerCase();
+    switch (ext) {
+        case '.csv':
+        case '.tsv':
+        case '.txt':
+            return new CSVBackend(resolvedPath, force);
+        default:
+            return new XLSXBackend(resolvedPath, force);
+    }
+}