jtcsv 3.0.0 → 3.1.1

package/dist/jtcsv-core.umd.js

@@ -15,6 +15,9 @@
             this.name = 'JTCSVError';
             this.code = code;
             this.details = details;
+            this.hint = details.hint;
+            this.docs = details.docs;
+            this.context = details.context;
             // Сохранение stack trace
             if (Error.captureStackTrace) {
                 Error.captureStackTrace(this, JTCSVError);
@@ -210,6 +213,12 @@
             if (error instanceof LimitError && error.limit && error.actual) {
                 message += ` (limit: ${error.limit}, actual: ${error.actual})`;
             }
+            if (error.hint) {
+                message += `\nHint: ${error.hint}`;
+            }
+            if (error.docs) {
+                message += `\nDocs: ${error.docs}`;
+            }
         }
         if (includeStack && error.stack) {
             message += `\n${error.stack}`;
@@ -291,6 +300,9 @@
         if (options?.rfc4180Compliant !== undefined && typeof options.rfc4180Compliant !== 'boolean') {
             throw new ConfigurationError('rfc4180Compliant must be a boolean');
         }
+        if (options?.normalizeQuotes !== undefined && typeof options.normalizeQuotes !== 'boolean') {
+            throw new ConfigurationError('normalizeQuotes must be a boolean');
+        }
         return true;
     }
     /**
@@ -302,8 +314,35 @@
             return '';
         }
         const str = String(value);
+        const isPotentialFormula = (input) => {
+            let idx = 0;
+            while (idx < input.length) {
+                const code = input.charCodeAt(idx);
+                if (code === 32 || code === 9 || code === 10 || code === 13 || code === 0xfeff) {
+                    idx++;
+                    continue;
+                }
+                break;
+            }
+            if (idx < input.length && (input[idx] === '"' || input[idx] === "'")) {
+                idx++;
+                while (idx < input.length) {
+                    const code = input.charCodeAt(idx);
+                    if (code === 32 || code === 9) {
+                        idx++;
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if (idx >= input.length) {
+                return false;
+            }
+            const char = input[idx];
+            return char === '=' || char === '+' || char === '-' || char === '@';
+        };
         // Экранирование формул для предотвращения CSV инъекций
-        if (preventInjection && /^[=+\-@]/.test(str)) {
+        if (preventInjection && isPotentialFormula(str)) {
             return "'" + str;
         }
         // Экранирование кавычек и переносов строк
@@ -312,6 +351,43 @@
         }
         return str;
     }
+    function normalizeQuotesInField$2(value) {
+        // Не нормализуем кавычки в JSON-строках - это ломает структуру JSON
+        // Проверяем, выглядит ли значение как JSON (объект или массив)
+        if ((value.startsWith('{') && value.endsWith('}')) ||
+            (value.startsWith('[') && value.endsWith(']'))) {
+            return value; // Возвращаем как есть для JSON
+        }
+        let normalized = value.replace(/"{2,}/g, '"');
+        // Убираем правило, которое ломает JSON: не заменяем "," на ","
+        // normalized = normalized.replace(/"\s*,\s*"/g, ',');
+        normalized = normalized.replace(/"\n/g, '\n').replace(/\n"/g, '\n');
+        if (normalized.length >= 2 && normalized.startsWith('"') && normalized.endsWith('"')) {
+            normalized = normalized.slice(1, -1);
+        }
+        return normalized;
+    }
+    function normalizePhoneValue$2(value) {
+        const trimmed = value.trim();
+        if (trimmed === '') {
+            return trimmed;
+        }
+        return trimmed.replace(/["'\\]/g, '');
+    }
+    function normalizeValueForCsv$1(value, key, normalizeQuotes) {
+        if (!normalizeQuotes || typeof value !== 'string') {
+            return value;
+        }
+        const base = normalizeQuotesInField$2(value);
+        if (!key) {
+            return base;
+        }
+        const phoneKeys = new Set(['phone', 'phonenumber', 'phone_number', 'tel', 'telephone']);
+        if (phoneKeys.has(String(key).toLowerCase())) {
+            return normalizePhoneValue$2(base);
+        }
+        return base;
+    }
     /**
      * Извлечение всех уникальных ключей из массива объектов
      * @private
@@ -344,6 +420,7 @@
             const maxRecords = options.maxRecords || data.length;
             const preventInjection = options.preventCsvInjection !== false;
             const rfc4180Compliant = options.rfc4180Compliant !== false;
+            const normalizeQuotes = options.normalizeQuotes !== false;
             // Ограничение количества записей
             const limitedData = data.slice(0, maxRecords);
             // Извлечение всех ключей
@@ -362,7 +439,8 @@
             for (const item of limitedData) {
                 const rowValues = allKeys.map(key => {
                     const value = item?.[key];
-                    return escapeCsvValue(value, preventInjection);
+                    const normalized = normalizeValueForCsv$1(value, key, normalizeQuotes);
+                    return escapeCsvValue(normalized, preventInjection);
                 });
                 lines.push(rowValues.join(delimiter));
             }
@@ -392,6 +470,7 @@
         const includeHeaders = options.includeHeaders !== false;
         const preventInjection = options.preventCsvInjection !== false;
         const rfc4180Compliant = options.rfc4180Compliant !== false;
+        const normalizeQuotes = options.normalizeQuotes !== false;
         let allKeys = [];
         let renameMap = {};
         // Если данные - массив, обрабатываем как массив
@@ -411,7 +490,8 @@
             for (const item of data) {
                 const rowValues = allKeys.map(key => {
                     const value = item?.[key];
-                    return escapeCsvValue(value, preventInjection);
+                    const normalized = normalizeValueForCsv$1(value, key, normalizeQuotes);
+                    return escapeCsvValue(normalized, preventInjection);
                 });
                 yield rowValues.join(delimiter) + (rfc4180Compliant ? '\r\n' : '\n');
             }
@@ -508,6 +588,12 @@
         if (options?.warnExtraFields !== undefined && typeof options.warnExtraFields !== 'boolean') {
             throw new ConfigurationError('warnExtraFields must be a boolean');
         }
+        if (options?.repairRowShifts !== undefined && typeof options.repairRowShifts !== 'boolean') {
+            throw new ConfigurationError('repairRowShifts must be a boolean');
+        }
+        if (options?.normalizeQuotes !== undefined && typeof options.normalizeQuotes !== 'boolean') {
+            throw new ConfigurationError('normalizeQuotes must be a boolean');
+        }
         return true;
     }
     /**
@@ -533,6 +619,169 @@
         }
         return bestCandidate;
     }
+    function isEmptyValue(value) {
+        return value === undefined || value === null || value === '';
+    }
+    function hasOddQuotes(value) {
+        if (typeof value !== 'string') {
+            return false;
+        }
+        let count = 0;
+        for (let i = 0; i < value.length; i++) {
+            if (value[i] === '"') {
+                count++;
+            }
+        }
+        return count % 2 === 1;
+    }
+    function hasAnyQuotes(value) {
+        return typeof value === 'string' && value.includes('"');
+    }
+    function normalizeQuotesInField$1(value) {
+        if (typeof value !== 'string') {
+            return value;
+        }
+        // Не нормализуем кавычки в JSON-строках - это ломает структуру JSON
+        // Проверяем, выглядит ли значение как JSON (объект или массив)
+        if ((value.startsWith('{') && value.endsWith('}')) ||
+            (value.startsWith('[') && value.endsWith(']'))) {
+            return value; // Возвращаем как есть для JSON
+        }
+        let normalized = value.replace(/"{2,}/g, '"');
+        // Убираем правило, которое ломает JSON: не заменяем "," на ","
+        // normalized = normalized.replace(/"\s*,\s*"/g, ',');
+        normalized = normalized.replace(/"\n/g, '\n').replace(/\n"/g, '\n');
+        if (normalized.length >= 2 && normalized.startsWith('"') && normalized.endsWith('"')) {
+            normalized = normalized.slice(1, -1);
+        }
+        return normalized;
+    }
+    function normalizePhoneValue$1(value) {
+        if (typeof value !== 'string') {
+            return value;
+        }
+        const trimmed = value.trim();
+        if (trimmed === '') {
+            return trimmed;
+        }
+        return trimmed.replace(/["'\\]/g, '');
+    }
+    function normalizeRowQuotes(row, headers) {
+        const normalized = {};
+        const phoneKeys = new Set(['phone', 'phonenumber', 'phone_number', 'tel', 'telephone']);
+        for (const header of headers) {
+            const baseValue = normalizeQuotesInField$1(row[header]);
+            if (phoneKeys.has(String(header).toLowerCase())) {
+                normalized[header] = normalizePhoneValue$1(baseValue);
+            }
+            else {
+                normalized[header] = baseValue;
+            }
+        }
+        return normalized;
+    }
+    function looksLikeUserAgent(value) {
+        if (typeof value !== 'string') {
+            return false;
+        }
+        return /Mozilla\/|Opera\/|MSIE|AppleWebKit|Gecko|Safari|Chrome\//.test(value);
+    }
+    function isHexColor(value) {
+        return typeof value === 'string' && /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.test(value);
+    }
+    function repairShiftedRows(rows, headers, options = {}) {
+        if (!Array.isArray(rows) || rows.length === 0 || headers.length === 0) {
+            return rows;
+        }
+        const headerCount = headers.length;
+        const merged = [];
+        let index = 0;
+        while (index < rows.length) {
+            const row = rows[index];
+            if (!row || typeof row !== 'object') {
+                merged.push(row);
+                index++;
+                continue;
+            }
+            const values = headers.map((header) => row[header]);
+            let lastNonEmpty = -1;
+            for (let i = headerCount - 1; i >= 0; i--) {
+                if (!isEmptyValue(values[i])) {
+                    lastNonEmpty = i;
+                    break;
+                }
+            }
+            const missingCount = headerCount - 1 - lastNonEmpty;
+            if (lastNonEmpty >= 0 && missingCount > 0 && index + 1 < rows.length) {
+                const nextRow = rows[index + 1];
+                if (nextRow && typeof nextRow === 'object') {
+                    const nextValues = headers.map((header) => nextRow[header]);
+                    const nextTrailingEmpty = nextValues
+                        .slice(headerCount - missingCount)
+                        .every((value) => isEmptyValue(value));
+                    const leadValues = nextValues
+                        .slice(0, missingCount)
+                        .filter((value) => !isEmptyValue(value));
+                    const shouldMerge = nextTrailingEmpty
+                        && leadValues.length > 0
+                        && (hasOddQuotes(values[lastNonEmpty]) || hasAnyQuotes(values[lastNonEmpty]));
+                    if (shouldMerge) {
+                        const toAppend = leadValues.map((value) => String(value));
+                        if (toAppend.length > 0) {
+                            const base = isEmptyValue(values[lastNonEmpty]) ? '' : String(values[lastNonEmpty]);
+                            values[lastNonEmpty] = base ? `${base}\n${toAppend.join('\n')}` : toAppend.join('\n');
+                        }
+                        for (let i = 0; i < missingCount; i++) {
+                            values[lastNonEmpty + 1 + i] = nextValues[missingCount + i];
+                        }
+                        const mergedRow = {};
+                        for (let i = 0; i < headerCount; i++) {
+                            mergedRow[headers[i]] = values[i];
+                        }
+                        merged.push(mergedRow);
+                        index += 2;
+                        continue;
+                    }
+                }
+            }
+            if (index + 1 < rows.length && headerCount >= 6) {
+                const nextRow = rows[index + 1];
+                if (nextRow && typeof nextRow === 'object') {
+                    const nextHex = nextRow[headers[4]];
+                    const nextUserAgentHead = nextRow[headers[2]];
+                    const nextUserAgentTail = nextRow[headers[3]];
+                    const shouldMergeUserAgent = isEmptyValue(values[4])
+                        && isEmptyValue(values[5])
+                        && isHexColor(nextHex)
+                        && (looksLikeUserAgent(nextUserAgentHead) || looksLikeUserAgent(nextUserAgentTail));
+                    if (shouldMergeUserAgent) {
+                        const addressParts = [values[3], nextRow[headers[0]], nextRow[headers[1]]]
+                            .filter((value) => !isEmptyValue(value))
+                            .map((value) => String(value));
+                        values[3] = addressParts.join('\n');
+                        const uaHead = isEmptyValue(nextUserAgentHead) ? '' : String(nextUserAgentHead);
+                        const uaTail = isEmptyValue(nextUserAgentTail) ? '' : String(nextUserAgentTail);
+                        const joiner = uaHead && uaTail ? (uaTail.startsWith(' ') ? '' : ',') : '';
+                        values[4] = uaHead + joiner + uaTail;
+                        values[5] = String(nextHex);
+                        const mergedRow = {};
+                        for (let i = 0; i < headerCount; i++) {
+                            mergedRow[headers[i]] = values[i];
+                        }
+                        merged.push(mergedRow);
+                        index += 2;
+                        continue;
+                    }
+                }
+            }
+            merged.push(row);
+            index++;
+        }
+        if (options.normalizeQuotes) {
+            return merged.map((row) => normalizeRowQuotes(row, headers));
+        }
+        return merged;
+    }
     /**
      * Парсинг CSV строки в массив объектов
      *
@@ -559,6 +808,7 @@
             }
             // Парсинг заголовков
             const headers = lines[0].split(delimiter).map(h => h.trim());
+            const { repairRowShifts = true, normalizeQuotes = true } = options || {};
             // Ограничение количества строк
             const maxRows = options.maxRows || Infinity;
             const dataRows = lines.slice(1, Math.min(lines.length, maxRows + 1));
@@ -584,6 +834,12 @@
                 }
                 result.push(row);
             }
+            if (repairRowShifts) {
+                return repairShiftedRows(result, headers, { normalizeQuotes });
+            }
+            if (normalizeQuotes) {
+                return result.map((row) => normalizeRowQuotes(row, headers));
+            }
             return result;
         });
     }
@@ -625,10 +881,12 @@
         }
         // Парсинг заголовков
         const headers = lines[0].split(delimiter).map(h => h.trim());
+        const { repairRowShifts = true, normalizeQuotes = true } = options || {};
         // Ограничение количества строк
         const maxRows = options.maxRows || Infinity;
         const dataRows = lines.slice(1, Math.min(lines.length, maxRows + 1));
         // Возврат данных по одной строке
+        const parsedRows = [];
         for (let i = 0; i < dataRows.length; i++) {
             const line = dataRows[i];
             const values = line.split(delimiter);
@@ -636,7 +894,7 @@
             for (let j = 0; j < headers.length; j++) {
                 const header = headers[j];
                 const value = j < values.length ? values[j].trim() : '';
-                // Попытка парсинга чисел
+                // Try parsing numbers
                 if (/^-?\d+(\.\d+)?$/.test(value)) {
                     row[header] = parseFloat(value);
                 }
@@ -647,6 +905,14 @@
                     row[header] = value;
                 }
             }
+            parsedRows.push(row);
+        }
+        const finalRows = repairRowShifts
+            ? repairShiftedRows(parsedRows, headers, { normalizeQuotes })
+            : (normalizeQuotes
+                ? parsedRows.map((row) => normalizeRowQuotes(row, headers))
+                : parsedRows);
+        for (const row of finalRows) {
             yield row;
         }
     }
@@ -705,6 +971,7 @@
         parseCsvSafeAsync: parseCsvSafeAsync
     });
 
+    const PHONE_KEYS = new Set(['phone', 'phonenumber', 'phone_number', 'tel', 'telephone']);
     function isReadableStream(value) {
         return value && typeof value.getReader === 'function';
     }
@@ -775,6 +1042,39 @@
         }
         return 'unknown';
     }
+    function normalizeQuotesInField(value) {
+        // Не нормализуем кавычки в JSON-строках - это ломает структуру JSON
+        // Проверяем, выглядит ли значение как JSON (объект или массив)
+        if ((value.startsWith('{') && value.endsWith('}')) ||
+            (value.startsWith('[') && value.endsWith(']'))) {
+            return value; // Возвращаем как есть для JSON
+        }
+        let normalized = value.replace(/"{2,}/g, '"');
+        // Убираем правило, которое ломает JSON: не заменяем "," на ","
+        // normalized = normalized.replace(/"\s*,\s*"/g, ',');
+        normalized = normalized.replace(/"\n/g, '\n').replace(/\n"/g, '\n');
+        if (normalized.length >= 2 && normalized.startsWith('"') && normalized.endsWith('"')) {
+            normalized = normalized.slice(1, -1);
+        }
+        return normalized;
+    }
+    function normalizePhoneValue(value) {
+        const trimmed = value.trim();
+        if (trimmed === '') {
+            return trimmed;
+        }
+        return trimmed.replace(/["'\\]/g, '');
+    }
+    function normalizeValueForCsv(value, key, normalizeQuotes) {
+        if (!normalizeQuotes || typeof value !== 'string') {
+            return value;
+        }
+        const base = normalizeQuotesInField(value);
+        if (key && PHONE_KEYS.has(String(key).toLowerCase())) {
+            return normalizePhoneValue(base);
+        }
+        return base;
+    }
     async function* jsonToCsvChunkIterator(input, options = {}) {
         const format = detectInputFormat(input, options);
         if (format === 'csv') {
@@ -817,6 +1117,34 @@
         const delimiter = options.delimiter || ';';
         const includeHeaders = options.includeHeaders !== false;
         const preventInjection = options.preventCsvInjection !== false;
+        const normalizeQuotes = options.normalizeQuotes !== false;
+        const isPotentialFormula = (input) => {
+            let idx = 0;
+            while (idx < input.length) {
+                const code = input.charCodeAt(idx);
+                if (code === 32 || code === 9 || code === 10 || code === 13 || code === 0xfeff) {
+                    idx++;
+                    continue;
+                }
+                break;
+            }
+            if (idx < input.length && (input[idx] === '"' || input[idx] === "'")) {
+                idx++;
+                while (idx < input.length) {
+                    const code = input.charCodeAt(idx);
+                    if (code === 32 || code === 9) {
+                        idx++;
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if (idx >= input.length) {
+                return false;
+            }
+            const char = input[idx];
+            return char === '=' || char === '+' || char === '-' || char === '@';
+        };
         let isFirstChunk = true;
         let headers = [];
         while (true) {
@@ -830,7 +1158,7 @@
                 if (includeHeaders) {
                     const headerLine = headers.map(header => {
                         const escaped = header.includes('"') ? `"${header.replace(/"/g, '""')}"` : header;
-                        return preventInjection && /^[=+\-@]/.test(escaped) ? `'${escaped}` : escaped;
+                        return preventInjection && isPotentialFormula(escaped) ? `'${escaped}` : escaped;
                     }).join(delimiter);
                     yield headerLine + '\n';
                 }
@@ -838,11 +1166,12 @@
             }
             const row = headers.map(header => {
                 const value = item[header];
-                const strValue = value === null || value === undefined ? '' : String(value);
+                const normalized = normalizeValueForCsv(value, header, normalizeQuotes);
+                const strValue = normalized === null || normalized === undefined ? '' : String(normalized);
                 if (strValue.includes('"') || strValue.includes('\n') || strValue.includes('\r') || strValue.includes(delimiter)) {
                     return `"${strValue.replace(/"/g, '""')}"`;
                 }
-                if (preventInjection && /^[=+\-@]/.test(strValue)) {
+                if (preventInjection && isPotentialFormula(strValue)) {
                     return `'${strValue}`;
                 }
                 return strValue;