jtcsv 2.1.0 → 2.1.3

package/plugins/remix/README.md

@@ -0,0 +1,26 @@
+# @jtcsv/remix
+
+Remix helpers for JTCSV.
+
+## Install
+```bash
+npm install @jtcsv/remix jtcsv
+```
+
+## Usage
+```typescript
+import { parseFormData, generateCsvResponse } from 'jtcsv/remix';
+
+export async function action({ request }) {
+  const rows = await parseFormData(request, { delimiter: ',' });
+  return { parsed: rows };
+}
+
+export async function loader() {
+  return generateCsvResponse([{ id: 1, name: 'John' }], 'export.csv');
+}
+```
+
+## Notes
+- `parseFormData` looks for a file field named `file` by default.
+- You can override the field name with `{ fieldName: 'upload' }`.

package/plugins/remix/index.d.ts

@@ -0,0 +1,16 @@
+import type { CsvToJsonOptions, JsonToCsvOptions } from 'jtcsv';
+
+export interface RemixCsvParseOptions extends CsvToJsonOptions {
+  fieldName?: string;
+}
+
+export function parseFormData(
+  request: Request,
+  options?: RemixCsvParseOptions
+): Promise<unknown[]>;
+
+export function generateCsvResponse(
+  data: unknown[] | Record<string, unknown>,
+  filename?: string,
+  options?: JsonToCsvOptions
+): Response;

package/plugins/remix/index.js

@@ -0,0 +1,62 @@
+const jtcsv = require('jtcsv');
+
+function normalizeFilename(filename) {
+  if (!filename || typeof filename !== 'string') {
+    return 'export.csv';
+  }
+  return filename.includes('.') ? filename : `${filename}.csv`;
+}
+
+async function extractCsvText(formData, fieldName) {
+  if (formData.has(fieldName)) {
+    const value = formData.get(fieldName);
+    if (value && typeof value.text === 'function') {
+      return await value.text();
+    }
+    if (value != null) {
+      return String(value);
+    }
+  }
+
+  for (const value of formData.values()) {
+    if (value && typeof value.text === 'function') {
+      return await value.text();
+    }
+  }
+
+  return null;
+}
+
+async function parseFormData(request, options = {}) {
+  if (!request || typeof request.formData !== 'function') {
+    throw new Error('parseFormData expects a Remix Request with formData()');
+  }
+
+  const { fieldName = 'file', ...csvOptions } = options;
+  const formData = await request.formData();
+  const csvText = await extractCsvText(formData, fieldName);
+
+  if (!csvText) {
+    throw new Error('No CSV file or field found in form data');
+  }
+
+  return jtcsv.csvToJson(csvText, csvOptions);
+}
+
+function generateCsvResponse(data, filename = 'export.csv', options = {}) {
+  const safeName = normalizeFilename(filename);
+  const rows = Array.isArray(data) ? data : [data];
+  const csv = jtcsv.jsonToCsv(rows, options);
+
+  return new Response(csv, {
+    headers: {
+      'Content-Type': 'text/csv; charset=utf-8',
+      'Content-Disposition': `attachment; filename="${safeName}"`
+    }
+  });
+}
+
+module.exports = {
+  parseFormData,
+  generateCsvResponse
+};

package/plugins/remix/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@jtcsv/remix",
+  "version": "1.0.0",
+  "description": "Remix helpers for JTCSV (form-data parsing and CSV responses)",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "keywords": [
+    "remix",
+    "csv",
+    "json",
+    "converter",
+    "jtcsv",
+    "formdata",
+    "response"
+  ],
+  "author": "Ruslan Fomenko",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Linol-Hamelton/jtcsv.git",
+    "directory": "plugins/remix"
+  },
+  "bugs": {
+    "url": "https://github.com/Linol-Hamelton/jtcsv/issues"
+  },
+  "homepage": "https://github.com/Linol-Hamelton/jtcsv/tree/main/plugins/remix#readme",
+  "peerDependencies": {
+    "jtcsv": "^2.1.3"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md"
+  ]
+}

package/plugins/sveltekit/README.md

@@ -0,0 +1,28 @@
+# @jtcsv/sveltekit
+
+SvelteKit helpers for JTCSV.
+
+## Install
+```bash
+npm install @jtcsv/sveltekit jtcsv
+```
+
+## Usage
+```typescript
+import { parseCsv, generateCsv } from 'jtcsv/sveltekit';
+
+export const actions = {
+  upload: async ({ request }) => {
+    const rows = await parseCsv(request, { delimiter: ',' });
+    return { success: true, rows };
+  }
+};
+
+export async function GET() {
+  return generateCsv([{ id: 1, name: 'John' }], 'export.csv');
+}
+```
+
+## Notes
+- `parseCsv` reads `request.text()` by default.
+- Use `{ formData: true, fieldName: 'file' }` for multipart uploads.

package/plugins/sveltekit/index.d.ts

@@ -0,0 +1,17 @@
+import type { CsvToJsonOptions, JsonToCsvOptions } from 'jtcsv';
+
+export interface SvelteKitCsvParseOptions extends CsvToJsonOptions {
+  fieldName?: string;
+  formData?: boolean;
+}
+
+export function parseCsv(
+  request: Request,
+  options?: SvelteKitCsvParseOptions
+): Promise<unknown[]>;
+
+export function generateCsv(
+  data: unknown[] | Record<string, unknown>,
+  filename?: string,
+  options?: JsonToCsvOptions
+): Response;

package/plugins/sveltekit/index.js

@@ -0,0 +1,54 @@
+const jtcsv = require('jtcsv');
+
+function normalizeFilename(filename) {
+  if (!filename || typeof filename !== 'string') {
+    return 'export.csv';
+  }
+  return filename.includes('.') ? filename : `${filename}.csv`;
+}
+
+async function parseCsv(request, options = {}) {
+  if (!request || typeof request.text !== 'function') {
+    throw new Error('parseCsv expects a Request instance');
+  }
+
+  const { fieldName = 'file', ...csvOptions } = options;
+  const contentType = request.headers?.get?.('content-type') || '';
+  let csvText = null;
+
+  if (options.formData || contentType.includes('multipart/form-data')) {
+    const formData = await request.formData();
+    const value = formData.get(fieldName) ?? formData.values().next().value;
+    if (value && typeof value.text === 'function') {
+      csvText = await value.text();
+    } else if (value != null) {
+      csvText = String(value);
+    }
+  } else {
+    csvText = await request.text();
+  }
+
+  if (!csvText) {
+    throw new Error('No CSV payload found in request');
+  }
+
+  return jtcsv.csvToJson(csvText, csvOptions);
+}
+
+function generateCsv(data, filename = 'export.csv', options = {}) {
+  const safeName = normalizeFilename(filename);
+  const rows = Array.isArray(data) ? data : [data];
+  const csv = jtcsv.jsonToCsv(rows, options);
+
+  return new Response(csv, {
+    headers: {
+      'Content-Type': 'text/csv; charset=utf-8',
+      'Content-Disposition': `attachment; filename="${safeName}"`
+    }
+  });
+}
+
+module.exports = {
+  parseCsv,
+  generateCsv
+};

package/plugins/sveltekit/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@jtcsv/sveltekit",
+  "version": "1.0.0",
+  "description": "SvelteKit helpers for JTCSV",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "keywords": [
+    "sveltekit",
+    "csv",
+    "json",
+    "converter",
+    "jtcsv"
+  ],
+  "author": "Ruslan Fomenko",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Linol-Hamelton/jtcsv.git",
+    "directory": "plugins/sveltekit"
+  },
+  "bugs": {
+    "url": "https://github.com/Linol-Hamelton/jtcsv/issues"
+  },
+  "homepage": "https://github.com/Linol-Hamelton/jtcsv/tree/main/plugins/sveltekit#readme",
+  "peerDependencies": {
+    "jtcsv": "^2.1.3"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md"
+  ]
+}

package/plugins/trpc/README.md

@@ -0,0 +1,22 @@
+# @jtcsv/trpc
+
+tRPC helper for JTCSV.
+
+## Install
+```bash
+npm install @jtcsv/trpc jtcsv
+```
+
+## Usage
+```typescript
+import { initTRPC } from '@trpc/server';
+import { z } from 'zod';
+import { createCsvProcedure } from 'jtcsv/trpc';
+
+const t = initTRPC.create();
+
+export const router = t.router({
+  parseCsv: createCsvProcedure(t, z.string(), { delimiter: ',' })
+    .mutation(async ({ input }) => ({ parsed: input }))
+});
+```

package/plugins/trpc/index.d.ts

@@ -0,0 +1,7 @@
+import type { CsvToJsonOptions } from 'jtcsv';
+
+export function createCsvProcedure<TProcedureBuilder>(
+  t: { procedure: TProcedureBuilder },
+  schema: unknown,
+  options?: CsvToJsonOptions
+): TProcedureBuilder;

package/plugins/trpc/index.js

@@ -0,0 +1,32 @@
+const jtcsv = require('jtcsv');
+
+function extractCsvText(input) {
+  if (typeof input === 'string') {
+    return input;
+  }
+  if (input && typeof input === 'object' && typeof input.csv === 'string') {
+    return input.csv;
+  }
+  return null;
+}
+
+function createCsvProcedure(t, schema, options = {}) {
+  if (!t || !t.procedure) {
+    throw new Error('createCsvProcedure expects initTRPC instance');
+  }
+
+  return t.procedure
+    .input(schema)
+    .use(async ({ input, next }) => {
+      const csvText = extractCsvText(input);
+      if (!csvText) {
+        throw new Error('CSV input must be a string or { csv: string }');
+      }
+      const parsed = jtcsv.csvToJson(csvText, options);
+      return next({ input: parsed });
+    });
+}
+
+module.exports = {
+  createCsvProcedure
+};

package/plugins/trpc/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@jtcsv/trpc",
+  "version": "1.0.0",
+  "description": "tRPC helper for JTCSV CSV parsing",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "keywords": [
+    "trpc",
+    "csv",
+    "json",
+    "converter",
+    "jtcsv"
+  ],
+  "author": "Ruslan Fomenko",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Linol-Hamelton/jtcsv.git",
+    "directory": "plugins/trpc"
+  },
+  "bugs": {
+    "url": "https://github.com/Linol-Hamelton/jtcsv/issues"
+  },
+  "homepage": "https://github.com/Linol-Hamelton/jtcsv/tree/main/plugins/trpc#readme",
+  "peerDependencies": {
+    "@trpc/server": "^10.0.0",
+    "jtcsv": "^2.1.3"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md"
+  ]
+}

package/src/core/delimiter-cache.js

@@ -0,0 +1,186 @@
+/**
+ * Кэширование результатов авто-детектирования разделителя
+ * Использует WeakMap и LRU кэш для оптимизации производительности
+ * 
+ * @version 1.0.0
+ * @date 2026-01-23
+ */
+
+class DelimiterCache {
+  constructor(maxSize = 100) {
+    this.weakMap = new WeakMap();
+    this.lruCache = new Map();
+    this.maxSize = maxSize;
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      evictions: 0,
+      size: 0
+    };
+  }
+
+  /**
+   * Генерирует ключ кэша на основе строки и кандидатов
+   * @private
+   */
+  _generateKey(csv, candidates) {
+    // Используем хэш первых 1000 символов для производительности
+    const sample = csv.substring(0, Math.min(1000, csv.length));
+    const candidatesKey = candidates.join(',');
+    return `${this._hashString(sample)}:${candidatesKey}`;
+  }
+
+  /**
+   * Простая хэш-функция для строк
+   * @private
+   */
+  _hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash; // Convert to 32bit integer
+    }
+    return hash.toString(36);
+  }
+
+  /**
+   * Получает значение из кэша
+   * @param {string} csv - CSV строка
+   * @param {Array} candidates - Кандидаты разделителей
+   * @returns {string|null} Кэшированный разделитель или null
+   */
+  get(csv, candidates) {
+    const key = this._generateKey(csv, candidates);
+    
+    // Проверяем LRU кэш
+    if (this.lruCache.has(key)) {
+      // Обновляем позицию в LRU
+      const value = this.lruCache.get(key);
+      this.lruCache.delete(key);
+      this.lruCache.set(key, value);
+      this.stats.hits++;
+      return value;
+    }
+    
+    this.stats.misses++;
+    return null;
+  }
+
+  /**
+   * Сохраняет значение в кэш
+   * @param {string} csv - CSV строка
+   * @param {Array} candidates - Кандидаты разделителей
+   * @param {string} delimiter - Найденный разделитель
+   */
+  set(csv, candidates, delimiter) {
+    const key = this._generateKey(csv, candidates);
+    
+    // Проверяем необходимость вытеснения из LRU кэша
+    if (this.lruCache.size >= this.maxSize) {
+      // Удаляем самый старый элемент (первый в Map)
+      const firstKey = this.lruCache.keys().next().value;
+      this.lruCache.delete(firstKey);
+      this.stats.evictions++;
+    }
+    
+    // Сохраняем в LRU кэш
+    this.lruCache.set(key, delimiter);
+    this.stats.size = this.lruCache.size;
+    
+    // Также сохраняем в WeakMap если csv является объектом
+    if (typeof csv === 'object' && csv !== null) {
+      this.weakMap.set(csv, { candidates, delimiter });
+    }
+  }
+
+  /**
+   * Очищает кэш
+   */
+  clear() {
+    this.lruCache.clear();
+    this.weakMap = new WeakMap();
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      evictions: 0,
+      size: 0
+    };
+  }
+
+  /**
+   * Возвращает статистику кэша
+   * @returns {Object} Статистика
+   */
+  getStats() {
+    const total = this.stats.hits + this.stats.misses;
+    return {
+      ...this.stats,
+      hitRate: total > 0 ? (this.stats.hits / total) * 100 : 0,
+      totalRequests: total
+    };
+  }
+
+  /**
+   * Оптимизированная версия autoDetectDelimiter с кэшированием
+   * @param {string} csv - CSV строка
+   * @param {Array} candidates - Кандидаты разделителей
+   * @param {DelimiterCache} cache - Экземпляр кэша (опционально)
+   * @returns {string} Найденный разделитель
+   */
+  static autoDetectDelimiter(csv, candidates = [';', ',', '\t', '|'], cache = null) {
+    if (!csv || typeof csv !== 'string') {
+      return ';';
+    }
+
+    // Проверяем кэш если он предоставлен
+    if (cache) {
+      const cached = cache.get(csv, candidates);
+      if (cached !== null) {
+        return cached;
+      }
+    }
+
+    const lines = csv.split('\n').filter(line => line.trim().length > 0);
+    
+    if (lines.length === 0) {
+      return ';';
+    }
+
+    // Используем первую непустую строку для детектирования
+    const firstLine = lines[0];
+    
+    const counts = {};
+    candidates.forEach(delim => {
+      const escapedDelim = delim.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const regex = new RegExp(escapedDelim, 'g');
+      const matches = firstLine.match(regex);
+      counts[delim] = matches ? matches.length : 0;
+    });
+
+    // Находим разделитель с максимальным количеством
+    let maxCount = -1;
+    let detectedDelimiter = ';';
+    
+    for (const [delim, count] of Object.entries(counts)) {
+      if (count > maxCount) {
+        maxCount = count;
+        detectedDelimiter = delim;
+      }
+    }
+
+    // Если разделитель не найден или есть ничья, возвращаем стандартный
+    if (maxCount === 0) {
+      detectedDelimiter = ';';
+    }
+
+    // Сохраняем в кэш если он предоставлен
+    if (cache) {
+      cache.set(csv, candidates, detectedDelimiter);
+    }
+
+    return detectedDelimiter;
+  }
+}
+
+module.exports = DelimiterCache;