jtcsv 3.0.0 → 3.1.1

package/plugins/sveltekit/index.ts

@@ -1,301 +0,0 @@
-/**
- * SvelteKit plugin for jtcsv
- * Provides utilities for CSV parsing and generation in SvelteKit applications
- * @module plugins/sveltekit
- */
-
-import { csvToJson, jsonToCsv } from '../../index-core';
-import type { CsvToJsonOptions, JsonToCsvOptions } from '../../src/types';
-
-/**
- * SvelteKit Request type (simplified)
- */
-interface SvelteKitRequest {
-  text(): Promise<string>;
-  formData(): Promise<FormData>;
-  headers?: {
-    get(name: string): string | null;
-  };
-}
-
-/**
- * Options for CSV parsing from request
- */
-export interface ParseCsvOptions extends CsvToJsonOptions {
-  /** Field name containing the CSV file (default: 'file') */
-  fieldName?: string;
-  /** Force form data parsing (default: auto-detect) */
-  formData?: boolean;
-}
-
-/**
- * Options for CSV response generation
- */
-export interface GenerateCsvOptions extends JsonToCsvOptions {
-  // Additional options specific to CSV response
-}
-
-/**
- * Normalize filename for CSV download
- */
-function normalizeFilename(filename?: string): string {
-  if (!filename || typeof filename !== 'string') {
-    return 'export.csv';
-  }
-  return filename.includes('.') ? filename : `${filename}.csv`;
-}
-
-/**
- * Extract CSV text from FormData
- */
-async function extractCsvText(formData: FormData, fieldName: string): Promise<string | null> {
-  if (formData.has(fieldName)) {
-    const value = formData.get(fieldName);
-    if (value && typeof (value as any).text === 'function') {
-      return await (value as any).text();
-    }
-    if (value !== null) {
-      return String(value);
-    }
-  }
-
-  for (const value of formData.values()) {
-    if (value && typeof (value as any).text === 'function') {
-      return await (value as any).text();
-    }
-  }
-
-  return null;
-}
-
-/**
- * Parse CSV from SvelteKit request
- * 
- * @example
- * // In a SvelteKit endpoint:
- * export async function POST({ request }) {
- *   const data = await parseCsv(request, { delimiter: ',' });
- *   return json({ success: true, data });
- * }
- */
-export async function parseCsv(
-  request: SvelteKitRequest,
-  options: ParseCsvOptions = {}
-): Promise<any[]> {
-  if (!request || typeof request.text !== 'function') {
-    throw new Error('parseCsv expects a Request instance');
-  }
-
-  const { fieldName = 'file', formData: forceFormData, ...csvOptions } = options;
-  const contentType = request.headers?.get?.('content-type') || '';
-  let csvText: string | null = null;
-
-  if (forceFormData || contentType.includes('multipart/form-data')) {
-    const formData = await request.formData();
-    csvText = await extractCsvText(formData, fieldName);
-  } else {
-    csvText = await request.text();
-  }
-
-  if (!csvText) {
-    throw new Error('No CSV payload found in request');
-  }
-
-  return await csvToJson(csvText, csvOptions);
-}
-
-/**
- * Async version of parseCsv with better error handling
- */
-export async function parseCsvAsync(
-  request: SvelteKitRequest,
-  options: ParseCsvOptions = {}
-): Promise<any[]> {
-  try {
-    return await parseCsv(request, options);
-  } catch (error) {
-    throw new Error(`Failed to parse CSV from request: ${error instanceof Error ? error.message : 'Unknown error'}`);
-  }
-}
-
-/**
- * Generate a CSV response for SvelteKit
- * 
- * @example
- * // In a SvelteKit endpoint:
- * export async function GET() {
- *   const data = await getData();
- *   return generateCsv(data, 'export.csv');
- * }
- */
-export function generateCsv(
-  data: any,
-  filename: string = 'export.csv',
-  options: GenerateCsvOptions = {}
-): Response {
-  const safeName = normalizeFilename(filename);
-  const rows = Array.isArray(data) ? data : [data];
-  const csv = jsonToCsv(rows, options);
-
-  return new Response(csv, {
-    headers: {
-      'Content-Type': 'text/csv; charset=utf-8',
-      'Content-Disposition': `attachment; filename="${safeName}"`
-    }
-  });
-}
-
-/**
- * Async version of generateCsv
- */
-export async function generateAsyncCsv(
-  data: any,
-  filename: string = 'export.csv',
-  options: GenerateCsvOptions = {}
-): Promise<Response> {
-  const safeName = normalizeFilename(filename);
-  const rows = Array.isArray(data) ? data : [data];
-  const csv = await jsonToCsv(rows, options);
-
-  return new Response(csv, {
-    headers: {
-      'Content-Type': 'text/csv; charset=utf-8',
-      'Content-Disposition': `attachment; filename="${safeName}"`
-    }
-  });
-}
-
-/**
- * CSV loader helper for SvelteKit
- * Creates a loader that returns CSV data
- * 
- * @example
- * export const loader = createCsvLoader(async () => {
- *   return await getData();
- * }, 'data.csv');
- */
-export function createCsvLoader(
-  dataLoader: () => Promise<any> | any,
-  filename: string = 'export.csv',
-  options: GenerateCsvOptions = {}
-): () => Promise<Response> {
-  return async () => {
-    try {
-      const data = await (typeof dataLoader === 'function' ? dataLoader() : dataLoader);
-      return generateCsv(data, filename, options);
-    } catch (error) {
-      return new Response(
-        JSON.stringify({ error: error instanceof Error ? error.message : 'Unknown error' }),
-        { status: 500, headers: { 'Content-Type': 'application/json' } }
-      );
-    }
-  };
-}
-
-/**
- * CSV action helper for SvelteKit
- * Creates an action that parses CSV from form data
- * 
- * @example
- * export const action = createCsvAction({ delimiter: ',' });
- */
-export function createCsvAction(
-  options: ParseCsvOptions = {}
-): (args: { request: SvelteKitRequest }) => Promise<Response> {
-  return async ({ request }) => {
-    try {
-      const data = await parseCsv(request, options);
-      return new Response(
-        JSON.stringify({ success: true, data }),
-        { headers: { 'Content-Type': 'application/json' } }
-      );
-    } catch (error) {
-      return new Response(
-        JSON.stringify({ 
-          success: false, 
-          error: error instanceof Error ? error.message : 'Unknown error' 
-        }),
-        { status: 400, headers: { 'Content-Type': 'application/json' } }
-      );
-    }
-  };
-}
-
-/**
- * Multi-part form data CSV parser
- * Handles multiple CSV files in a single request
- */
-export async function parseMultiPartCsv(
-  request: SvelteKitRequest,
-  options: ParseCsvOptions & { multiple?: boolean } = {}
-): Promise<any[] | any[][]> {
-  const { multiple = false, ...csvOptions } = options;
-  const formData = await request.formData();
-  const results: any[][] = [];
-
-  for (const [fieldName, value] of formData.entries()) {
-    if (value && typeof (value as any).text === 'function') {
-      const csvText = await (value as any).text();
-      if (csvText) {
-        const parsed = await csvToJson(csvText, csvOptions);
-        results.push(parsed);
-      }
-    }
-  }
-
-  if (!multiple && results.length > 0) {
-    return results[0];
-  }
-
-  return results;
-}
-
-/**
- * CSV export utility for SvelteKit routes
- */
-export function csvExport(
-  data: any,
-  filename?: string,
-  options?: GenerateCsvOptions
-): () => Promise<Response> {
-  return () => generateAsyncCsv(data, filename, options);
-}
-
-/**
- * SvelteKit server hook for CSV processing
- * Can be used in hooks.server.js/ts
- */
-export function createCsvHook(options: {
-  parseOptions?: ParseCsvOptions;
-  generateOptions?: GenerateCsvOptions;
-} = {}) {
-  return {
-    async handle({ event, resolve }: { event: any; resolve: any }) {
-      // Add CSV utilities to event.locals
-      event.locals.csv = {
-        parse: (request: SvelteKitRequest, opts?: ParseCsvOptions) => 
-          parseCsv(request, { ...options.parseOptions, ...opts }),
-        parseAsync: (request: SvelteKitRequest, opts?: ParseCsvOptions) => 
-          parseCsvAsync(request, { ...options.parseOptions, ...opts }),
-        generate: (data: any, filename?: string, opts?: GenerateCsvOptions) => 
-          generateCsv(data, filename, { ...options.generateOptions, ...opts }),
-        generateAsync: (data: any, filename?: string, opts?: GenerateCsvOptions) => 
-          generateAsyncCsv(data, filename, { ...options.generateOptions, ...opts }),
-      };
-
-      return resolve(event);
-    }
-  };
-}
-
-export default {
-  parseCsv,
-  parseCsvAsync,
-  generateCsv,
-  generateAsyncCsv,
-  createCsvLoader,
-  createCsvAction,
-  parseMultiPartCsv,
-  csvExport,
-  createCsvHook,
-};

package/plugins/sveltekit/package.json

@@ -1,33 +0,0 @@
-{
-  "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

@@ -1,25 +0,0 @@
-# @jtcsv/trpc
-
-Middleware helper that parses CSV input for tRPC procedures.
-
-## Install
-```bash
-npm install @jtcsv/trpc jtcsv
-```
-
-## Usage
-```javascript
-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())
-    .mutation(async ({ input }) => ({ rows: input }))
-});
-```
-
-## Exports
-- createCsvProcedure

package/plugins/trpc/index.d.ts

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

package/plugins/trpc/index.js

@@ -1,32 +0,0 @@
-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/index.ts

@@ -1,267 +0,0 @@
-/**
- * tRPC plugin for jtcsv
- * Provides utilities for CSV parsing and generation in tRPC applications
- * @module plugins/trpc
- */
-
-import { csvToJson, jsonToCsv } from '../../index-core';
-import type { CsvToJsonOptions, JsonToCsvOptions } from '../../src/types';
-
-/**
- * tRPC context type (simplified)
- */
-interface TRPCContext {
-  // tRPC context properties
-}
-
-/**
- * tRPC procedure type (simplified)
- */
-interface TRPCProcedure {
-  input(schema: any): any;
-  use(middleware: any): any;
-}
-
-/**
- * tRPC instance type (simplified)
- */
-interface TRPCInstance {
-  procedure: TRPCProcedure;
-}
-
-/**
- * Options for CSV parsing in tRPC procedures
- */
-export interface CsvProcedureOptions extends CsvToJsonOptions {
-  /** Whether to return raw CSV text instead of parsed JSON */
-  raw?: boolean;
-  /** Whether to use async parsing */
-  async?: boolean;
-}
-
-/**
- * Options for CSV generation in tRPC procedures
- */
-export interface CsvResponseOptions extends JsonToCsvOptions {
-  /** Filename for download (default: 'export.csv') */
-  filename?: string;
-  /** Whether to return as Response object */
-  asResponse?: boolean;
-  /** Whether to use async generation */
-  async?: boolean;
-}
-
-/**
- * Extract CSV text from various input formats
- */
-function extractCsvText(input: any): string | null {
-  if (typeof input === 'string') {
-    return input;
-  }
-  if (input && typeof input === 'object' && typeof input.csv === 'string') {
-    return input.csv;
-  }
-  if (input && typeof input === 'object' && input.file && typeof input.file.text === 'function') {
-    return input.file.text();
-  }
-  return null;
-}
-
-/**
- * Create a tRPC procedure for CSV parsing
- * 
- * @example
- * // In your tRPC router:
- * import { createCsvProcedure } from 'jtcsv/plugins/trpc';
- * 
- * export const csvRouter = t.router({
- *   parse: createCsvProcedure(t, z.string(), { delimiter: ',' })
- * });
- */
-export function createCsvProcedure(
-  t: TRPCInstance,
-  schema: any,
-  options: CsvProcedureOptions = {}
-): any {
-  if (!t || !t.procedure) {
-    throw new Error('createCsvProcedure expects initTRPC instance');
-  }
-
-  return t.procedure
-    .input(schema)
-    .use(async ({ input, next }: { input: any; next: any }) => {
-      const csvText = extractCsvText(input);
-      if (!csvText) {
-        throw new Error('CSV input must be a string or { csv: string }');
-      }
-
-      if (options.async) {
-        const parsed = await csvToJson(csvText, options);
-        return next({ input: parsed });
-      } else {
-        const parsed = csvToJson(csvText, options);
-        return next({ input: parsed });
-      }
-    });
-}
-
-/**
- * Async version of createCsvProcedure
- */
-export function createAsyncCsvProcedure(
-  t: TRPCInstance,
-  schema: any,
-  options: CsvProcedureOptions = {}
-): any {
-  return createCsvProcedure(t, schema, { ...options, async: true });
-}
-
-/**
- * Create a tRPC procedure for CSV generation
- * 
- * @example
- * // In your tRPC router:
- * import { createCsvResponseProcedure } from 'jtcsv/plugins/trpc';
- * 
- * export const csvRouter = t.router({
- *   export: createCsvResponseProcedure(t, z.array(z.any()), { filename: 'data.csv' })
- * });
- */
-export function createCsvResponseProcedure(
-  t: TRPCInstance,
-  schema: any,
-  options: CsvResponseOptions = {}
-): any {
-  if (!t || !t.procedure) {
-    throw new Error('createCsvResponseProcedure expects initTRPC instance');
-  }
-
-  return t.procedure
-    .input(schema)
-    .use(async ({ input, next }: { input: any; next: any }) => {
-      const { filename = 'export.csv', asResponse = false, ...csvOptions } = options;
-      const rows = Array.isArray(input) ? input : [input];
-      
-      if (options.async) {
-        const csv = await jsonToCsv(rows, csvOptions);
-        
-        if (asResponse) {
-          const response = new Response(csv, {
-            headers: {
-              'Content-Type': 'text/csv; charset=utf-8',
-              'Content-Disposition': `attachment; filename="${filename}"`
-            }
-          });
-          return next({ input: response });
-        }
-        
-        return next({ input: csv });
-      } else {
-        const csv = jsonToCsv(rows, csvOptions);
-        
-        if (asResponse) {
-          const response = new Response(csv, {
-            headers: {
-              'Content-Type': 'text/csv; charset=utf-8',
-              'Content-Disposition': `attachment; filename="${filename}"`
-            }
-          });
-          return next({ input: response });
-        }
-        
-        return next({ input: csv });
-      }
-    });
-}
-
-/**
- * Async version of createCsvResponseProcedure
- */
-export function createAsyncCsvResponseProcedure(
-  t: TRPCInstance,
-  schema: any,
-  options: CsvResponseOptions = {}
-): any {
-  return createCsvResponseProcedure(t, schema, { ...options, async: true });
-}
-
-/**
- * Create a complete tRPC router for CSV operations
- * 
- * @example
- * // In your tRPC setup:
- * import { createCsvRouter } from 'jtcsv/plugins/trpc';
- * 
- * export const csvRouter = createCsvRouter(t);
- */
-export function createCsvRouter(t: TRPCInstance, options: {
-  parseOptions?: CsvProcedureOptions;
-  responseOptions?: CsvResponseOptions;
-} = {}) {
-  if (!t || !t.procedure) {
-    throw new Error('createCsvRouter expects initTRPC instance');
-  }
-
-  return {
-    parse: createCsvProcedure(t, z.string(), options.parseOptions),
-    parseAsync: createAsyncCsvProcedure(t, z.string(), options.parseOptions),
-    export: createCsvResponseProcedure(t, z.array(z.any()), options.responseOptions),
-    exportAsync: createAsyncCsvResponseProcedure(t, z.array(z.any()), options.responseOptions),
-    batch: t.procedure
-      .input(z.array(z.string()))
-      .use(async ({ input, next }: { input: string[]; next: any }) => {
-        const results = await Promise.all(
-          input.map((csv: string) => csvToJson(csv, options.parseOptions))
-        );
-        return next({ input: results });
-      }),
-    batchAsync: t.procedure
-      .input(z.array(z.string()))
-      .use(async ({ input, next }: { input: string[]; next: any }) => {
-        const results = await Promise.all(
-          input.map((csv: string) => csvToJson(csv, options.parseOptions))
-        );
-        return next({ input: results });
-      }),
-  };
-}
-
-/**
- * tRPC middleware for CSV processing
- * Adds CSV utilities to tRPC context
- */
-export function createCsvMiddleware(options: CsvProcedureOptions = {}) {
-  return async ({ ctx, next }: { ctx: TRPCContext; next: any }) => {
-    const enhancedCtx = {
-      ...ctx,
-      csv: {
-        parse: (csvText: string) => csvToJson(csvText, options),
-        parseAsync: async (csvText: string) => await csvToJson(csvText, options),
-        generate: (data: any, opts?: JsonToCsvOptions) => jsonToCsv(data, { ...options, ...opts }),
-        generateAsync: async (data: any, opts?: JsonToCsvOptions) => 
-          await jsonToCsv(data, { ...options, ...opts }),
-      }
-    };
-
-    return next({ ctx: enhancedCtx });
-  };
-}
-
-/**
- * Zod schema for CSV input validation
- * Note: This is a placeholder - in real usage, import zod
- */
-const z = {
-  string: () => ({ _type: 'string' }),
-  array: (schema: any) => ({ _type: 'array', schema }),
-  any: () => ({ _type: 'any' }),
-};
-
-export default {
-  createCsvProcedure,
-  createAsyncCsvProcedure,
-  createCsvResponseProcedure,
-  createAsyncCsvResponseProcedure,
-  createCsvRouter,
-  createCsvMiddleware,
-};

package/plugins/trpc/package.json

@@ -1,34 +0,0 @@
-{
-  "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"
-  ]
-}