recker 1.0.26 → 1.0.27-next.8396df6

package/dist/transport/fetch.js

@@ -1,12 +1,29 @@
 export class FetchTransport {
-    constructor() { }
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
     async dispatch(req) {
         const start = performance.now();
+        let timeoutId;
+        let abortController;
+        const timeoutMs = typeof req.timeout === 'number'
+            ? req.timeout
+            : req.timeout?.request;
+        let signal = req.signal;
+        if (timeoutMs && !signal) {
+            abortController = new AbortController();
+            signal = abortController.signal;
+            timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
+        }
         const requestInit = {
             method: req.method,
             headers: req.headers,
             body: req.body,
-            signal: req.signal,
+            signal,
+            credentials: this.options.credentials,
+            cache: this.options.cache,
+            keepalive: this.options.keepalive ?? true,
             duplex: req.body ? 'half' : undefined
         };
         try {
@@ -16,84 +33,22 @@ export class FetchTransport {
                 total: totalTime,
                 firstByte: totalTime,
             };
-            const reckerResponse = {
-                status: response.status,
-                statusText: response.statusText,
-                headers: response.headers,
-                ok: response.ok,
-                url: response.url,
-                timings,
-                raw: response,
-                json: () => response.json(),
-                text: () => response.text(),
-                blob: () => response.blob(),
-                cleanText: async () => {
-                    const text = await response.text();
-                    return text.replace(/<[^>]*>?/gm, '');
-                },
-                read: () => response.body,
-                clone: () => {
-                    const cloned = response.clone();
-                    return createReckerResponseWrapper(cloned, timings);
-                },
-                async *sse() {
-                    if (!response.body)
-                        return;
-                    const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done)
-                            break;
-                        const lines = value.split('\n');
-                        for (const line of lines) {
-                            if (line.startsWith('data: ')) {
-                                yield { data: line.slice(6) };
-                            }
-                        }
-                    }
-                },
-                async *download() {
-                    if (!response.body)
-                        return;
-                    const reader = response.body.getReader();
-                    let loaded = 0;
-                    const total = Number(response.headers.get('content-length')) || undefined;
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done)
-                            break;
-                        loaded += value.length;
-                        yield {
-                            loaded,
-                            transferred: loaded,
-                            total,
-                            percent: total ? (loaded / total) * 100 : undefined,
-                            direction: 'download'
-                        };
-                    }
-                },
-                async *[Symbol.asyncIterator]() {
-                    if (!response.body)
-                        return;
-                    const reader = response.body.getReader();
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done)
-                            break;
-                        yield value;
-                    }
-                }
-            };
-            return reckerResponse;
+            return new FetchResponseWrapper(response, timings);
         }
         catch (error) {
+            if (error.name === 'AbortError' && abortController) {
+                const timeoutError = new Error(`Request timeout after ${timeoutMs}ms`);
+                timeoutError.name = 'TimeoutError';
+                throw timeoutError;
+            }
             throw error;
         }
+        finally {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+        }
     }
 }
-function createReckerResponseWrapper(response, timings) {
-    return new FetchResponseWrapper(response, timings);
-}
 class FetchResponseWrapper {
     raw;
     timings;
@@ -118,12 +73,39 @@ class FetchResponseWrapper {
             return;
         const stream = this.raw.body.pipeThrough(new TextDecoderStream());
         const reader = stream.getReader();
+        let buffer = '';
         while (true) {
             const { done, value } = await reader.read();
             if (done)
                 break;
-            if (value.startsWith('data: ')) {
-                yield { data: value.slice(6) };
+            buffer += value;
+            const events = buffer.split('\n\n');
+            buffer = events.pop() || '';
+            for (const event of events) {
+                if (!event.trim())
+                    continue;
+                let data = '';
+                let eventType;
+                let id;
+                let retry;
+                const lines = event.split('\n');
+                for (const line of lines) {
+                    if (line.startsWith('data: ')) {
+                        data = data ? data + '\n' + line.slice(6) : line.slice(6);
+                    }
+                    else if (line.startsWith('event: ')) {
+                        eventType = line.slice(7);
+                    }
+                    else if (line.startsWith('id: ')) {
+                        id = line.slice(4);
+                    }
+                    else if (line.startsWith('retry: ')) {
+                        retry = parseInt(line.slice(7), 10);
+                    }
+                }
+                if (data) {
+                    yield { data, event: eventType, id, retry };
+                }
             }
         }
     }

package/dist/utils/columns.d.ts

@@ -0,0 +1,14 @@
+export interface ColumnOptions {
+    minWidth?: number;
+    maxColumns?: number;
+    padding?: number;
+    prefix?: string;
+    indent?: number;
+    transform?: (item: string) => string;
+}
+export declare function getTerminalWidth(): number;
+export declare function formatColumns(items: string[], options?: ColumnOptions): string;
+export declare function formatColumnsRowMajor(items: string[], options?: ColumnOptions): string;
+export declare function formatGroupedColumns(groups: Record<string, string[]>, options?: ColumnOptions & {
+    groupPrefix?: string;
+}): string;

package/dist/utils/columns.js

@@ -0,0 +1,69 @@
+export function getTerminalWidth() {
+    return process.stdout.columns || 80;
+}
+export function formatColumns(items, options = {}) {
+    const { minWidth = 15, maxColumns = Infinity, padding = 2, prefix = '', indent = 2, transform, } = options;
+    if (items.length === 0)
+        return '';
+    const prefixedItems = items.map(item => prefix + item);
+    const maxItemWidth = Math.max(...prefixedItems.map(item => item.length));
+    const columnWidth = Math.max(minWidth, maxItemWidth + padding);
+    const terminalWidth = getTerminalWidth();
+    const availableWidth = terminalWidth - indent;
+    const calculatedColumns = Math.floor(availableWidth / columnWidth);
+    const numColumns = Math.min(Math.max(1, calculatedColumns), maxColumns, items.length);
+    const actualColumnWidth = Math.floor(availableWidth / numColumns);
+    const numRows = Math.ceil(prefixedItems.length / numColumns);
+    const lines = [];
+    const indentStr = ' '.repeat(indent);
+    for (let row = 0; row < numRows; row++) {
+        let line = indentStr;
+        for (let col = 0; col < numColumns; col++) {
+            const index = col * numRows + row;
+            if (index < prefixedItems.length) {
+                const rawItem = prefixedItems[index];
+                const displayItem = transform ? transform(rawItem) : rawItem;
+                const paddingNeeded = actualColumnWidth - rawItem.length;
+                line += displayItem + ' '.repeat(Math.max(0, paddingNeeded));
+            }
+        }
+        lines.push(line.trimEnd());
+    }
+    return lines.join('\n');
+}
+export function formatColumnsRowMajor(items, options = {}) {
+    const { minWidth = 15, maxColumns = Infinity, padding = 2, prefix = '', indent = 2, } = options;
+    if (items.length === 0)
+        return '';
+    const prefixedItems = items.map(item => prefix + item);
+    const maxItemWidth = Math.max(...prefixedItems.map(item => item.length));
+    const columnWidth = Math.max(minWidth, maxItemWidth + padding);
+    const terminalWidth = getTerminalWidth();
+    const availableWidth = terminalWidth - indent;
+    const calculatedColumns = Math.floor(availableWidth / columnWidth);
+    const numColumns = Math.min(Math.max(1, calculatedColumns), maxColumns, items.length);
+    const actualColumnWidth = Math.floor(availableWidth / numColumns);
+    const lines = [];
+    const indentStr = ' '.repeat(indent);
+    for (let i = 0; i < prefixedItems.length; i += numColumns) {
+        let line = indentStr;
+        for (let col = 0; col < numColumns && i + col < prefixedItems.length; col++) {
+            const item = prefixedItems[i + col];
+            line += item.padEnd(actualColumnWidth);
+        }
+        lines.push(line.trimEnd());
+    }
+    return lines.join('\n');
+}
+export function formatGroupedColumns(groups, options = {}) {
+    const lines = [];
+    const { groupPrefix = '', ...columnOptions } = options;
+    for (const [groupName, items] of Object.entries(groups)) {
+        if (items.length === 0)
+            continue;
+        lines.push(groupPrefix + groupName + ':');
+        lines.push(formatColumns(items, columnOptions));
+        lines.push('');
+    }
+    return lines.join('\n').trimEnd();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recker",
-  "version": "1.0.26",
+  "version": "1.0.27-next.8396df6",
   "description": "AI & DevX focused HTTP client for Node.js 18+",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -58,6 +58,24 @@
   ],
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
+      "node": {
+        "import": "./dist/index.js",
+        "require": "./dist/index.cjs"
+      },
+      "browser": {
+        "import": "./dist/browser/browser/index.js",
+        "default": "./dist/browser/browser/index.js"
+      },
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser/browser/index.d.ts",
+      "import": "./dist/browser/browser/index.js",
+      "default": "./dist/browser/browser/index.js"
+    },
+    "./node": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
@@ -114,8 +132,15 @@
       "types": "./dist/mini.d.ts",
       "import": "./dist/mini.js"
     },
+    "./presets/*": {
+      "types": "./dist/presets/*.d.ts",
+      "import": "./dist/presets/*.js"
+    },
     "./package.json": "./package.json"
   },
+  "browser": "./dist/browser/browser/index.js",
+  "unpkg": "./dist/browser/index.umd.min.js",
+  "jsdelivr": "./dist/browser/index.umd.min.js",
   "bin": {
     "rek": "./dist/cli/index.js",
     "recker": "./dist/cli/index.js"
@@ -164,8 +189,10 @@
     "commander": "^14.0.0",
     "cross-fetch": "^4.1.0",
     "domhandler": "^5.0.3",
+    "esbuild": "^0.24.2",
     "fastembed": "^2.0.0",
     "got": "^14.6.5",
+    "happy-dom": "^20.0.11",
     "husky": "^9.1.7",
     "ky": "^1.14.0",
     "make-fetch-happen": "^15.0.3",
@@ -186,11 +213,16 @@
     "zod": "^4.1.13"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "pnpm build:node && pnpm build:browser",
+    "build:node": "tsc",
+    "build:browser": "tsc -p tsconfig.browser.json",
+    "build:browser:bundle": "pnpm build:browser && node scripts/bundle-browser.js",
     "build:embeddings": "tsx scripts/build-embeddings.ts",
     "test": "NODE_OPTIONS='--max-old-space-size=512' vitest run",
     "test:coverage": "NODE_OPTIONS='--max-old-space-size=512' vitest run --coverage",
     "test:light": "NODE_OPTIONS='--max-old-space-size=256' vitest run --poolOptions.forks.maxForks=1",
+    "test:browser": "vitest run --config vitest.config.browser.ts",
+    "test:browser:coverage": "vitest run --config vitest.config.browser.ts --coverage",
     "bench": "tsx benchmark/index.ts",
     "bench:compare": "tsx benchmark/http-clients-comparison.ts",
     "bench:all": "tsx benchmark/run-all.ts",