recker 1.0.35 → 1.0.36-next.4f24ba8

package/dist/browser/plugins/csv.d.ts

@@ -0,0 +1,42 @@
+import type { ReckerResponse } from '../types/index.js';
+export declare const CSV_MEDIA_TYPES: readonly ["text/csv", "application/csv", "text/x-csv", "application/x-csv"];
+export declare const CSV_SUFFIX = "+csv";
+export declare function isCsvContentType(contentType: string | null): boolean;
+export interface CsvParseOptions {
+    headers?: boolean;
+    columns?: string[];
+    delimiter?: string;
+    quote?: string;
+    skipEmptyLines?: boolean;
+    trim?: boolean;
+    parseNumbers?: boolean;
+    parseBooleans?: boolean;
+    comment?: string;
+    maxRows?: number;
+    maxColumns?: number;
+}
+export interface CsvSerializeOptions {
+    headers?: boolean;
+    columns?: string[];
+    delimiter?: string;
+    quote?: string;
+    alwaysQuote?: boolean;
+    lineEnding?: string;
+    nullValue?: string;
+}
+export declare function parseCsv<T = Record<string, string>>(csv: string, options: CsvParseOptions & {
+    headers?: true;
+}): T[];
+export declare function parseCsv(csv: string, options: CsvParseOptions & {
+    headers: false;
+}): string[][];
+export declare function parseCsv<T = Record<string, string>>(csv: string, options?: CsvParseOptions): T[] | string[][];
+export declare class CsvError extends Error {
+    row?: number;
+    constructor(message: string, row?: number);
+}
+export declare function serializeCsv(data: Record<string, any>[] | any[][], options?: CsvSerializeOptions): string;
+export declare function csvResponse<T = Record<string, string>>(promise: Promise<ReckerResponse>, options?: CsvParseOptions): Promise<T[]>;
+export declare function parseCsvTyped<T = Record<string, any>>(csv: string, options?: Omit<CsvParseOptions, 'parseNumbers' | 'parseBooleans'>): T[];
+export declare function parseCsvStream<T = Record<string, string>>(stream: ReadableStream<Uint8Array> | null, options?: CsvParseOptions): AsyncGenerator<T>;
+export { parseCsv as csvParse, serializeCsv as csvSerialize };

package/dist/browser/plugins/csv.js

@@ -0,0 +1,386 @@
+export const CSV_MEDIA_TYPES = [
+    'text/csv',
+    'application/csv',
+    'text/x-csv',
+    'application/x-csv',
+];
+export const CSV_SUFFIX = '+csv';
+export function isCsvContentType(contentType) {
+    if (!contentType)
+        return false;
+    const ct = contentType.toLowerCase().split(';')[0].trim();
+    return CSV_MEDIA_TYPES.includes(ct) || ct.endsWith(CSV_SUFFIX);
+}
+export function parseCsv(csv, options = {}) {
+    const opts = {
+        headers: options.headers ?? true,
+        columns: options.columns,
+        delimiter: options.delimiter ?? ',',
+        quote: options.quote ?? '"',
+        skipEmptyLines: options.skipEmptyLines ?? true,
+        trim: options.trim ?? false,
+        parseNumbers: options.parseNumbers ?? false,
+        parseBooleans: options.parseBooleans ?? false,
+        comment: options.comment,
+        maxRows: options.maxRows ?? 100000,
+        maxColumns: options.maxColumns ?? 1000,
+    };
+    if (!csv || !csv.trim()) {
+        return [];
+    }
+    const normalized = csv.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    const rows = [];
+    let currentRow = [];
+    let currentField = '';
+    let inQuotes = false;
+    let rowCount = 0;
+    for (let i = 0; i < normalized.length; i++) {
+        const char = normalized[i];
+        const nextChar = normalized[i + 1];
+        if (inQuotes) {
+            if (char === opts.quote) {
+                if (nextChar === opts.quote) {
+                    currentField += opts.quote;
+                    i++;
+                }
+                else {
+                    inQuotes = false;
+                }
+            }
+            else {
+                currentField += char;
+            }
+        }
+        else {
+            if (char === opts.quote && currentField === '') {
+                inQuotes = true;
+            }
+            else if (char === opts.delimiter) {
+                currentRow.push(processField(currentField, opts));
+                currentField = '';
+                if (currentRow.length > opts.maxColumns) {
+                    throw new CsvError(`Maximum columns (${opts.maxColumns}) exceeded`, rowCount);
+                }
+            }
+            else if (char === '\n') {
+                currentRow.push(processField(currentField, opts));
+                currentField = '';
+                if (opts.comment && currentRow.length === 1 && currentRow[0].startsWith(opts.comment)) {
+                    currentRow = [];
+                    continue;
+                }
+                if (opts.skipEmptyLines && currentRow.length === 1 && currentRow[0] === '') {
+                    currentRow = [];
+                    continue;
+                }
+                rows.push(currentRow);
+                currentRow = [];
+                rowCount++;
+                if (rowCount > opts.maxRows) {
+                    throw new CsvError(`Maximum rows (${opts.maxRows}) exceeded`, rowCount);
+                }
+            }
+            else {
+                currentField += char;
+            }
+        }
+    }
+    if (currentField || currentRow.length > 0) {
+        currentRow.push(processField(currentField, opts));
+        if (!(opts.comment && currentRow.length === 1 && currentRow[0].startsWith(opts.comment))) {
+            if (!(opts.skipEmptyLines && currentRow.length === 1 && currentRow[0] === '')) {
+                rows.push(currentRow);
+            }
+        }
+    }
+    if (!opts.headers && !opts.columns) {
+        return rows;
+    }
+    let headers;
+    let dataRows;
+    if (opts.columns) {
+        headers = opts.columns;
+        dataRows = opts.headers ? rows.slice(1) : rows;
+    }
+    else {
+        if (rows.length === 0) {
+            return [];
+        }
+        headers = rows[0];
+        dataRows = rows.slice(1);
+    }
+    return dataRows.map((row) => {
+        const obj = {};
+        for (let i = 0; i < headers.length; i++) {
+            obj[headers[i]] = row[i] ?? '';
+        }
+        return obj;
+    });
+}
+function processField(field, opts) {
+    let value = opts.trim ? field.trim() : field;
+    if (opts.parseNumbers) {
+        const num = Number(value);
+        if (!isNaN(num) && value !== '') {
+            return num;
+        }
+    }
+    if (opts.parseBooleans) {
+        const lower = value.toLowerCase();
+        if (lower === 'true')
+            return true;
+        if (lower === 'false')
+            return false;
+    }
+    return value;
+}
+export class CsvError extends Error {
+    row;
+    constructor(message, row) {
+        super(row !== undefined ? `${message} at row ${row + 1}` : message);
+        this.name = 'CsvError';
+        this.row = row;
+    }
+}
+export function serializeCsv(data, options = {}) {
+    const opts = {
+        headers: options.headers ?? true,
+        columns: options.columns,
+        delimiter: options.delimiter ?? ',',
+        quote: options.quote ?? '"',
+        alwaysQuote: options.alwaysQuote ?? false,
+        lineEnding: options.lineEnding ?? '\r\n',
+        nullValue: options.nullValue ?? '',
+    };
+    if (!data || data.length === 0) {
+        return '';
+    }
+    const lines = [];
+    const isArrayOfArrays = Array.isArray(data[0]);
+    if (isArrayOfArrays) {
+        for (const row of data) {
+            lines.push(row.map((field) => quoteField(field, opts)).join(opts.delimiter));
+        }
+    }
+    else {
+        const objects = data;
+        let columns;
+        if (opts.columns) {
+            columns = opts.columns;
+        }
+        else {
+            const keySet = new Set();
+            for (const obj of objects) {
+                for (const key of Object.keys(obj)) {
+                    keySet.add(key);
+                }
+            }
+            columns = Array.from(keySet);
+        }
+        if (opts.headers) {
+            lines.push(columns.map((col) => quoteField(col, opts)).join(opts.delimiter));
+        }
+        for (const obj of objects) {
+            const row = columns.map((col) => {
+                const value = obj[col];
+                return quoteField(value, opts);
+            });
+            lines.push(row.join(opts.delimiter));
+        }
+    }
+    return lines.join(opts.lineEnding);
+}
+function quoteField(value, opts) {
+    if (value === null || value === undefined) {
+        return opts.nullValue;
+    }
+    const str = String(value);
+    const needsQuoting = opts.alwaysQuote ||
+        str.includes(opts.quote) ||
+        str.includes(opts.delimiter) ||
+        str.includes('\n') ||
+        str.includes('\r');
+    if (needsQuoting) {
+        const escaped = str.replace(new RegExp(opts.quote, 'g'), opts.quote + opts.quote);
+        return opts.quote + escaped + opts.quote;
+    }
+    return str;
+}
+export async function csvResponse(promise, options) {
+    const response = await promise;
+    const text = await response.text();
+    return parseCsv(text, options);
+}
+export function parseCsvTyped(csv, options = {}) {
+    const rows = parseCsv(csv, { ...options, headers: true });
+    return rows.map((row) => {
+        const typed = {};
+        for (const [key, value] of Object.entries(row)) {
+            typed[key] = inferType(value);
+        }
+        return typed;
+    });
+}
+function inferType(value) {
+    if (value === '') {
+        return null;
+    }
+    const lower = value.toLowerCase();
+    if (lower === 'true')
+        return true;
+    if (lower === 'false')
+        return false;
+    if (/^-?\d+$/.test(value)) {
+        const num = parseInt(value, 10);
+        if (Number.isSafeInteger(num))
+            return num;
+    }
+    if (/^-?\d*\.?\d+([eE][-+]?\d+)?$/.test(value)) {
+        return parseFloat(value);
+    }
+    if (/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?)?$/.test(value)) {
+        const date = new Date(value);
+        if (!isNaN(date.getTime())) {
+            return date;
+        }
+    }
+    return value;
+}
+export async function* parseCsvStream(stream, options = {}) {
+    if (!stream)
+        return;
+    const opts = {
+        headers: options.headers ?? true,
+        columns: options.columns,
+        delimiter: options.delimiter ?? ',',
+        quote: options.quote ?? '"',
+        skipEmptyLines: options.skipEmptyLines ?? true,
+        trim: options.trim ?? false,
+        parseNumbers: options.parseNumbers ?? false,
+        parseBooleans: options.parseBooleans ?? false,
+        comment: options.comment,
+    };
+    const decoder = new TextDecoder();
+    const reader = stream.getReader();
+    let buffer = '';
+    let headers = opts.columns || null;
+    let isFirstRow = !opts.columns;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                if (buffer.trim()) {
+                    const row = parseRow(buffer, opts);
+                    if (row) {
+                        if (isFirstRow && opts.headers) {
+                            headers = row;
+                            isFirstRow = false;
+                        }
+                        else if (headers) {
+                            yield rowToObject(row, headers);
+                        }
+                        else {
+                            yield row;
+                        }
+                    }
+                }
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let newlineIndex;
+            while ((newlineIndex = findCompleteRow(buffer, opts.quote)) !== -1) {
+                const line = buffer.slice(0, newlineIndex);
+                buffer = buffer.slice(newlineIndex + 1);
+                if (buffer.startsWith('\r')) {
+                    buffer = buffer.slice(1);
+                }
+                const row = parseRow(line, opts);
+                if (!row)
+                    continue;
+                if (isFirstRow && opts.headers) {
+                    headers = row;
+                    isFirstRow = false;
+                    continue;
+                }
+                if (headers) {
+                    yield rowToObject(row, headers);
+                }
+                else {
+                    yield row;
+                }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function findCompleteRow(buffer, quote) {
+    let inQuotes = false;
+    for (let i = 0; i < buffer.length; i++) {
+        const char = buffer[i];
+        if (char === quote) {
+            if (inQuotes && buffer[i + 1] === quote) {
+                i++;
+            }
+            else {
+                inQuotes = !inQuotes;
+            }
+        }
+        else if ((char === '\n' || char === '\r') && !inQuotes) {
+            return i;
+        }
+    }
+    return -1;
+}
+function parseRow(line, opts) {
+    if (opts.comment && line.startsWith(opts.comment)) {
+        return null;
+    }
+    if (opts.skipEmptyLines && !line.trim()) {
+        return null;
+    }
+    const fields = [];
+    let currentField = '';
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        const nextChar = line[i + 1];
+        if (inQuotes) {
+            if (char === opts.quote) {
+                if (nextChar === opts.quote) {
+                    currentField += opts.quote;
+                    i++;
+                }
+                else {
+                    inQuotes = false;
+                }
+            }
+            else {
+                currentField += char;
+            }
+        }
+        else {
+            if (char === opts.quote && currentField === '') {
+                inQuotes = true;
+            }
+            else if (char === opts.delimiter) {
+                fields.push(processField(currentField, opts));
+                currentField = '';
+            }
+            else {
+                currentField += char;
+            }
+        }
+    }
+    fields.push(processField(currentField, opts));
+    return fields;
+}
+function rowToObject(row, headers) {
+    const obj = {};
+    for (let i = 0; i < headers.length; i++) {
+        obj[headers[i]] = row[i] ?? '';
+    }
+    return obj;
+}
+export { parseCsv as csvParse, serializeCsv as csvSerialize };

package/dist/browser/plugins/yaml.d.ts

@@ -0,0 +1,28 @@
+import type { ReckerResponse } from '../types/index.js';
+export declare const YAML_MEDIA_TYPES: readonly ["application/yaml", "application/x-yaml", "text/yaml", "text/x-yaml"];
+export declare const YAML_SUFFIX = "+yaml";
+export declare function isYamlContentType(contentType: string | null): boolean;
+export interface YamlParseOptions {
+    allowDuplicateKeys?: boolean;
+    parseDates?: boolean;
+    customTags?: Record<string, (value: string) => any>;
+    maxDepth?: number;
+    maxKeys?: number;
+}
+export interface YamlSerializeOptions {
+    indent?: number;
+    lineWidth?: number;
+    forceQuotes?: boolean;
+    flowStyle?: boolean;
+    sortKeys?: boolean;
+    skipUndefined?: boolean;
+    documentMarkers?: boolean;
+}
+export declare function parseYaml<T = any>(yaml: string, options?: YamlParseOptions): T;
+export declare class YamlError extends Error {
+    line?: number;
+    constructor(message: string, line?: number);
+}
+export declare function serializeYaml(data: any, options?: YamlSerializeOptions): string;
+export declare function yamlResponse<T = any>(promise: Promise<ReckerResponse>, options?: YamlParseOptions): Promise<T>;
+export { parseYaml as yamlParse, serializeYaml as yamlSerialize };