react-csv-autopilot 0.0.1-beta.2

package/README.md

@@ -0,0 +1,275 @@
+# react-csv-autopilot
+
+[![npm version](https://img.shields.io/npm/v/react-csv-autopilot?color=blue&logo=npm)](https://www.npmjs.com/package/react-csv-autopilot)
+[![npm downloads](https://img.shields.io/npm/dw/react-csv-autopilot?logo=npm)](https://www.npmjs.com/package/react-csv-autopilot)
+[![Bundle Size](https://img.shields.io/bundlephobia/minzip/react-csv-autopilot?color=green&logo=webpack)](https://bundlephobia.com/package/react-csv-autopilot)
+[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue?logo=typescript)](https://www.typescriptlang.org/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+**Drop the function, we handle the rest.**
+
+A React library for exporting large datasets to CSV with automatic pagination, streaming, and progress tracking. Built with Web Workers for non-blocking performance and File System Access API for efficient file writing.
+
+---
+
+## Features
+
+- **Automatic Pagination** - Just provide a `getNextPage` function, we handle the rest
+- **Streaming Export** - Uses ReadableStream for memory-efficient large file exports
+- **Non-blocking** - Web Workers for CSV conversion without freezing the UI
+- **Progress Tracking** - Real-time progress updates via BroadcastChannel
+- **TypeScript** - Full type safety with TypeScript definitions
+- **Zero Dependencies** - Only React as peer dependency
+- **Framework Agnostic Core** - Use the core logic in any JavaScript environment
+
+---
+
+## Installation
+
+```bash
+npm install react-csv-autopilot
+```
+
+```bash
+yarn add react-csv-autopilot
+```
+
+```bash
+pnpm add react-csv-autopilot
+```
+
+---
+
+## Quick Start
+
+```typescript
+import { useExportCSV, useMessageExportCSV } from 'react-csv-autopilot';
+
+function ExportButton() {
+  const { handler } = useExportCSV();
+
+  // Track export progress
+  useMessageExportCSV((progress) => {
+    if (progress.type === 'progress') {
+      console.log(`${progress.loadedItemsCount}/${progress.total}`);
+    }
+  });
+
+  const handleExport = async () => {
+    await handler.execute({
+      fileName: 'users-export',
+      columns: [
+        { key: 'id', label: 'ID' },
+        { key: 'name', label: 'Full Name' },
+        { key: 'email', label: 'Email Address' },
+      ],
+      getNextPage: async (offset) => {
+        // Fetch your data - this will be called automatically
+        const response = await fetch(`/api/users?page=${offset}&limit=100`);
+        const data = await response.json();
+        
+        return {
+          rows: data.users,
+          total: data.totalCount,
+        };
+      },
+    });
+  };
+
+  return <button onClick={handleExport}>Export to CSV</button>;
+}
+```
+
+---
+
+## 📖 API Reference
+
+### `useExportCSV()`
+
+Hook that provides access to the CSV export controller.
+
+**Returns:**
+```typescript
+{
+  handler: ExportController // Controller instance for executing exports
+}
+```
+
+**Example:**
+```typescript
+const { handler } = useExportCSV();
+
+await handler.execute({
+  fileName: 'data-export',
+  columns: [...],
+  getNextPage: async (offset) => {...}
+});
+```
+
+---
+
+### `useMessageExportCSV(callback, channelName?)`
+
+Hook for tracking export progress in real-time.
+
+**Parameters:**
+- `callback: (payload: ExportProgressPayload) => void` - Called on each progress update
+- `channelName?: string` - Optional custom channel name (default: `'EXPORT_CSV_CHANNEL'`)
+
+**Payload Type:**
+```typescript
+type ExportProgressPayload = {
+  total: number;
+  loadedItemsCount: number;
+  type: 'progress' | 'done' | 'failed';
+};
+```
+
+**Example:**
+```typescript
+const [progress, setProgress] = useState({ loaded: 0, total: 0 });
+
+useMessageExportCSV((payload) => {
+  setProgress({
+    loaded: payload.loadedItemsCount,
+    total: payload.total,
+  });
+
+  if (payload.type === 'done') {
+    console.log('Export completed!');
+  }
+});
+```
+
+---
+
+### Types
+
+#### `ExportParams`
+
+```typescript
+type ExportParams = {
+  fileName: string;
+  columns: Column[];
+  getNextPage: (offset: number) => Promise<{ rows: any[]; total: number }>;
+};
+```
+
+#### `Column`
+
+```typescript
+type Column = {
+  key: string;
+  label: string;
+  timezone?: 'UTC' | string;
+  formatType?: 'dateFull' | 'dateMediumTime' | 'timeShort' | 'numDecimal' | 'numCompact' | 'numCurrency' | 'numPercent';
+};
+```
+
+
+### Pagination Strategies
+
+**API with page numbers:**
+```typescript
+getNextPage: async (offset) => {
+  const page = offset + 1; // Convert to 1-based pagination
+  const response = await fetch(`/api/data?page=${page}&size=100`);
+  return await response.json();
+}
+```
+
+**API with cursor-based pagination:**
+```typescript
+let nextCursor = null;
+
+getNextPage: async (offset) => {
+  const url = offset === 0 
+    ? '/api/data?limit=100'
+    : `/api/data?cursor=${nextCursor}&limit=100`;
+    
+  const response = await fetch(url);
+  const data = await response.json();
+  
+  nextCursor = data.nextCursor;
+  
+  return {
+    rows: data.items,
+    total: data.totalCount,
+  };
+}
+```
+
+---
+
+## Architecture
+
+### How It Works
+
+1. **Stream-based Export** - Uses `ReadableStream` and File System Access API for efficient file writing
+2. **Web Workers** - CSV conversion happens in a separate thread to keep UI responsive
+3. **Automatic Pagination** - Calls your `getNextPage` function repeatedly until all data is fetched
+4. **Progress Tracking** - Uses `BroadcastChannel` to communicate progress across components
+
+```
+┌─────────────────┐
+│   React Hook    │
+│  useExportCSV() │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐      ┌──────────────┐
+│ Export          │─────▶│ Web Worker   │
+│ Controller      │      │ (CSV Convert)│
+└────────┬────────┘      └──────────────┘
+         │
+         ▼
+┌─────────────────┐      ┌──────────────┐
+│ ReadableStream  │─────▶│ File System  │
+│ (Pagination)    │      │ Access API   │
+└─────────────────┘      └──────────────┘
+```
+
+---
+
+## Browser Compatibility
+
+Requires browsers with support for:
+- **File System Access API** (Chrome 86+, Edge 86+)
+- **Web Workers** (All modern browsers)
+- **ReadableStream** (All modern browsers)
+
+> **Note:** For browsers without File System Access API, the library will fall back to Blob-based download.
+
+---
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+---
+
+## 📄 License
+
+MIT © [Pavlo Kuzina](../../LICENSE)
+
+---
+
+## 🔗 Links
+
+- **npm Package**: [react-csv-autopilot](https://www.npmjs.com/package/react-csv-autopilot)
+- **Repository**: [GitHub - utils-kit](https://github.com/PashaSchool/utils-kit)
+- **Issues**: [GitHub Issues](https://github.com/PashaSchool/utils-kit/issues)
+- **Monorepo**: Part of [utils-kit](../../README.md) collection
+
+---
+
+## Related Packages
+
+- [**react-url-query-params**](../react-url-query-params) - Type-safe URL query parameter management
+
+---
+
+<div align="center">
+  <sub>Built with ❤️ by <a href="https://github.com/PashaSchool">Pavlo Kuzina</a></sub>
+</div>
+

package/dist/index.cjs

@@ -0,0 +1,294 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  useExportCSV: () => useExportCSV_default,
+  useMessageExportCSV: () => useMessageExportCSV_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/hooks/useExportCSV.ts
+var import_react = require("react");
+
+// src/core/controllers/ExportController.ts
+var _ExportController_instances, canUseFSAccess_fn, resolveStrategy_fn;
+var ExportController = class {
+  constructor(deps) {
+    this.deps = deps;
+    __privateAdd(this, _ExportController_instances);
+  }
+  async start(params) {
+    const strategy = __privateMethod(this, _ExportController_instances, resolveStrategy_fn).call(this);
+    return strategy.export(params);
+  }
+};
+_ExportController_instances = new WeakSet();
+canUseFSAccess_fn = function() {
+  return typeof window.showSaveFilePicker === "function";
+};
+resolveStrategy_fn = function() {
+  if (__privateMethod(this, _ExportController_instances, canUseFSAccess_fn).call(this)) {
+    return this.deps.fsAccessStrategy;
+  }
+  return this.deps.blobExportStrategy;
+};
+
+// src/core/strategy/BolbExportStrategy.ts
+var BolbExportStrategy = class {
+  export(params) {
+    return Promise.resolve({});
+  }
+};
+var BolbExportStrategy_default = BolbExportStrategy;
+
+// src/core/contants/index.ts
+var WEB_WORKER_NAME = "scv-worker";
+var BROADCAST_CHANNEL_NAME = "react-csv-exporter";
+
+// src/core/WorkerManager.ts
+var import_meta = {};
+var pending = /* @__PURE__ */ new Map();
+var _worker, _WorkerManager_instances, listenerRegistry_fn;
+var _WorkerManager = class _WorkerManager {
+  constructor() {
+    __privateAdd(this, _WorkerManager_instances);
+    __privateAdd(this, _worker);
+    let workerUrl;
+    try {
+      workerUrl = new URL("./worker.js", import_meta.url);
+    } catch {
+      workerUrl = "/worker.js";
+    }
+    __privateSet(this, _worker, new Worker(workerUrl, {
+      type: "module",
+      name: WEB_WORKER_NAME
+    }));
+    __privateMethod(this, _WorkerManager_instances, listenerRegistry_fn).call(this);
+  }
+  static initialise() {
+    return new _WorkerManager();
+  }
+  async triggerWorker(payload) {
+    const id = payload.id ?? Math.random().toString(36).substr(2);
+    const p = new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+    });
+    __privateGet(this, _worker).postMessage(payload);
+    return p;
+  }
+  terminate() {
+    if (__privateGet(this, _worker)) {
+      __privateGet(this, _worker).terminate();
+      __privateSet(this, _worker, null);
+    }
+  }
+};
+_worker = new WeakMap();
+_WorkerManager_instances = new WeakSet();
+listenerRegistry_fn = function() {
+  __privateGet(this, _worker).addEventListener("message", (event) => {
+    const { id, result, error } = event.data;
+    const entity = pending.get(id);
+    if (!entity) {
+      return;
+    }
+    pending.delete(id);
+    if (error) {
+      entity.reject(error);
+    } else {
+      entity.resolve(result);
+    }
+  });
+  __privateGet(this, _worker).addEventListener("error", (event) => {
+    for (const [, { reject }] of pending) {
+      reject(event);
+    }
+    pending.clear();
+  });
+};
+var WorkerManager = _WorkerManager;
+var WorkerManager_default = WorkerManager;
+
+// src/core/strategy/FsAccessExportStrategy.ts
+var FsAccessExportStrategy = class {
+  constructor() {
+    this.workerManager = WorkerManager_default.initialise();
+  }
+  async export(params) {
+    const _suggestedName = params?.fileName || "export";
+    const fileHandle = await window.showSaveFilePicker({
+      suggestedName: _suggestedName,
+      types: [{ description: "CSV file", accept: { "text/csv": [".csv"] } }]
+    });
+    const writableFileStream = await fileHandle.createWritable();
+    let iterator = 0;
+    let totalRowsLoaded = 0;
+    const encoder = new TextEncoder();
+    const messaging = new BroadcastChannel(BROADCAST_CHANNEL_NAME);
+    const readable = new ReadableStream({
+      pull: async (controller) => {
+        try {
+          const response = await params.getNextPage(iterator++);
+          const safeRows = Array.isArray(response.rows) ? response?.rows : [];
+          const safeTotal = response.total ?? 0;
+          const isRowsEmpty = !safeRows || !safeRows.length;
+          totalRowsLoaded = isRowsEmpty ? safeTotal : totalRowsLoaded += safeRows.length;
+          const isFinished = totalRowsLoaded >= safeTotal;
+          if (isRowsEmpty) {
+            messaging.postMessage(
+              JSON.stringify({
+                type: "done",
+                total: safeTotal,
+                loadedItemsCount: totalRowsLoaded
+              })
+            );
+            await this.workerManager.triggerWorker({ id: iterator, type: "completed" });
+            messaging.close();
+            controller.close();
+            return;
+          }
+          const csvChunks = await this.workerManager.triggerWorker({
+            id: iterator,
+            type: "to_csv_chunk",
+            data: safeRows,
+            columns: params.columns
+          });
+          messaging.postMessage(
+            JSON.stringify({
+              type: "progress",
+              total: safeTotal,
+              loadedItemsCount: totalRowsLoaded
+            })
+          );
+          controller.enqueue(encoder.encode(csvChunks));
+          if (isFinished) {
+            messaging.postMessage(
+              JSON.stringify({
+                type: "done",
+                total: safeTotal,
+                loadedItemsCount: totalRowsLoaded
+              })
+            );
+            await this.workerManager.triggerWorker({ id: iterator, type: "completed" });
+            messaging.close();
+            controller.close();
+            return;
+          }
+        } catch (error) {
+          controller.error(error);
+          messaging.postMessage(
+            JSON.stringify({
+              type: "failed",
+              total: 0,
+              loadedItemsCount: totalRowsLoaded
+            })
+          );
+        }
+      }
+    });
+    try {
+      await readable.pipeTo(writableFileStream);
+    } catch (err) {
+      console.error("Export failed:", err);
+      throw err;
+    } finally {
+      this.workerManager.terminate();
+    }
+    return {
+      finished: true,
+      totalRowsLoaded,
+      logs: {
+        warnings: []
+      }
+    };
+  }
+};
+var FsAccessExportStrategy_default = FsAccessExportStrategy;
+
+// src/core/fabric/ExportControlFabric.ts
+var ExportControlFabric = class {
+  static create() {
+    const controller = new ExportController({
+      fsAccessStrategy: new FsAccessExportStrategy_default(),
+      blobExportStrategy: new BolbExportStrategy_default()
+    });
+    return controller;
+  }
+};
+
+// src/core/ExportControllerSingleton.ts
+var _ExportControllerSingleton = class _ExportControllerSingleton {
+  static init() {
+    if (_ExportControllerSingleton.instance) {
+      return _ExportControllerSingleton.instance;
+    }
+    _ExportControllerSingleton.instance = ExportControlFabric.create();
+    _ExportControllerSingleton.initialized = true;
+    return _ExportControllerSingleton.instance;
+  }
+  static getInstance() {
+    if (!_ExportControllerSingleton.instance) {
+      return _ExportControllerSingleton.init();
+    }
+    return _ExportControllerSingleton.instance;
+  }
+};
+_ExportControllerSingleton.instance = null;
+_ExportControllerSingleton.initialized = false;
+var ExportControllerSingleton = _ExportControllerSingleton;
+var ExportControllerSingleton_default = ExportControllerSingleton;
+
+// src/hooks/useExportCSV.ts
+function useExportCSV() {
+  const exportCallbackRef = (0, import_react.useRef)(ExportControllerSingleton_default.init());
+  return {
+    handler: exportCallbackRef.current
+  };
+}
+var useExportCSV_default = useExportCSV;
+
+// src/hooks/useMessageExportCSV.ts
+var import_react2 = require("react");
+function useMessageExportCSV(cb) {
+  (0, import_react2.useEffect)(() => {
+    const channel = new BroadcastChannel(BROADCAST_CHANNEL_NAME);
+    channel.addEventListener("message", (params) => {
+      try {
+        const json = JSON.parse(params.data);
+        cb(json);
+      } catch (error) {
+        console.error({ error });
+      }
+    });
+    return () => {
+      channel.close();
+    };
+  }, []);
+}
+var useMessageExportCSV_default = useMessageExportCSV;

package/dist/index.d.cts

@@ -0,0 +1,52 @@
+type formatterTypes = "dateFull" | "dateMediumTime" | "timeShort" | "numDecimal" | "numCompact" | "numCurrency" | "numPercent";
+type Column = {
+    key: string;
+    label: string;
+    timezone?: "UTC" | string;
+    formatType?: formatterTypes;
+};
+type ExportParams = {
+    fileName: string;
+    columns: Column[];
+    getNextPage: (offset: number) => Promise<{
+        rows: any[];
+        total: number;
+    }>;
+};
+interface ExportStrategy {
+    export(params: ExportParams): Promise<any>;
+}
+
+declare class BolbExportStrategy implements ExportStrategy {
+    export(params: ExportParams): Promise<any>;
+}
+
+declare class FsAccessExportStrategy implements ExportStrategy {
+    private workerManager;
+    constructor();
+    export(params: ExportParams): Promise<any>;
+}
+
+type ExportControllerDeps = {
+    fsAccessStrategy: FsAccessExportStrategy;
+    blobExportStrategy: BolbExportStrategy;
+};
+declare class ExportController {
+    #private;
+    private readonly deps;
+    constructor(deps: ExportControllerDeps);
+    start(params: ExportParams): Promise<any>;
+}
+
+declare function useExportCSV(): {
+    handler: ExportController;
+};
+
+type Payload = {
+    total: number;
+    loadedItemsCount: number;
+    state: "progress" | "failed" | "done";
+};
+declare function useMessageExportCSV(cb: (payload: Payload) => void): void;
+
+export { type Column, ExportController, type ExportParams, useExportCSV, useMessageExportCSV };

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+type formatterTypes = "dateFull" | "dateMediumTime" | "timeShort" | "numDecimal" | "numCompact" | "numCurrency" | "numPercent";
+type Column = {
+    key: string;
+    label: string;
+    timezone?: "UTC" | string;
+    formatType?: formatterTypes;
+};
+type ExportParams = {
+    fileName: string;
+    columns: Column[];
+    getNextPage: (offset: number) => Promise<{
+        rows: any[];
+        total: number;
+    }>;
+};
+interface ExportStrategy {
+    export(params: ExportParams): Promise<any>;
+}
+
+declare class BolbExportStrategy implements ExportStrategy {
+    export(params: ExportParams): Promise<any>;
+}
+
+declare class FsAccessExportStrategy implements ExportStrategy {
+    private workerManager;
+    constructor();
+    export(params: ExportParams): Promise<any>;
+}
+
+type ExportControllerDeps = {
+    fsAccessStrategy: FsAccessExportStrategy;
+    blobExportStrategy: BolbExportStrategy;
+};
+declare class ExportController {
+    #private;
+    private readonly deps;
+    constructor(deps: ExportControllerDeps);
+    start(params: ExportParams): Promise<any>;
+}
+
+declare function useExportCSV(): {
+    handler: ExportController;
+};
+
+type Payload = {
+    total: number;
+    loadedItemsCount: number;
+    state: "progress" | "failed" | "done";
+};
+declare function useMessageExportCSV(cb: (payload: Payload) => void): void;
+
+export { type Column, ExportController, type ExportParams, useExportCSV, useMessageExportCSV };

package/dist/index.js

@@ -0,0 +1,271 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/hooks/useExportCSV.ts
+import { useRef } from "react";
+
+// src/core/controllers/ExportController.ts
+var _ExportController_instances, canUseFSAccess_fn, resolveStrategy_fn;
+var ExportController = class {
+  constructor(deps) {
+    this.deps = deps;
+    __privateAdd(this, _ExportController_instances);
+  }
+  async start(params) {
+    const strategy = __privateMethod(this, _ExportController_instances, resolveStrategy_fn).call(this);
+    return strategy.export(params);
+  }
+};
+_ExportController_instances = new WeakSet();
+canUseFSAccess_fn = function() {
+  return typeof window.showSaveFilePicker === "function";
+};
+resolveStrategy_fn = function() {
+  if (__privateMethod(this, _ExportController_instances, canUseFSAccess_fn).call(this)) {
+    return this.deps.fsAccessStrategy;
+  }
+  return this.deps.blobExportStrategy;
+};
+
+// src/core/strategy/BolbExportStrategy.ts
+var BolbExportStrategy = class {
+  export(params) {
+    return Promise.resolve({});
+  }
+};
+var BolbExportStrategy_default = BolbExportStrategy;
+
+// src/core/contants/index.ts
+var WEB_WORKER_NAME = "scv-worker";
+var BROADCAST_CHANNEL_NAME = "react-csv-exporter";
+
+// src/core/WorkerManager.ts
+var pending = /* @__PURE__ */ new Map();
+var _worker, _WorkerManager_instances, listenerRegistry_fn;
+var _WorkerManager = class _WorkerManager {
+  constructor() {
+    __privateAdd(this, _WorkerManager_instances);
+    __privateAdd(this, _worker);
+    let workerUrl;
+    try {
+      workerUrl = new URL("./worker.js", import.meta.url);
+    } catch {
+      workerUrl = "/worker.js";
+    }
+    __privateSet(this, _worker, new Worker(workerUrl, {
+      type: "module",
+      name: WEB_WORKER_NAME
+    }));
+    __privateMethod(this, _WorkerManager_instances, listenerRegistry_fn).call(this);
+  }
+  static initialise() {
+    return new _WorkerManager();
+  }
+  async triggerWorker(payload) {
+    const id = payload.id ?? Math.random().toString(36).substr(2);
+    const p = new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+    });
+    __privateGet(this, _worker).postMessage(payload);
+    return p;
+  }
+  terminate() {
+    if (__privateGet(this, _worker)) {
+      __privateGet(this, _worker).terminate();
+      __privateSet(this, _worker, null);
+    }
+  }
+};
+_worker = new WeakMap();
+_WorkerManager_instances = new WeakSet();
+listenerRegistry_fn = function() {
+  __privateGet(this, _worker).addEventListener("message", (event) => {
+    const { id, result, error } = event.data;
+    const entity = pending.get(id);
+    if (!entity) {
+      return;
+    }
+    pending.delete(id);
+    if (error) {
+      entity.reject(error);
+    } else {
+      entity.resolve(result);
+    }
+  });
+  __privateGet(this, _worker).addEventListener("error", (event) => {
+    for (const [, { reject }] of pending) {
+      reject(event);
+    }
+    pending.clear();
+  });
+};
+var WorkerManager = _WorkerManager;
+var WorkerManager_default = WorkerManager;
+
+// src/core/strategy/FsAccessExportStrategy.ts
+var FsAccessExportStrategy = class {
+  constructor() {
+    this.workerManager = WorkerManager_default.initialise();
+  }
+  async export(params) {
+    const _suggestedName = params?.fileName || "export";
+    const fileHandle = await window.showSaveFilePicker({
+      suggestedName: _suggestedName,
+      types: [{ description: "CSV file", accept: { "text/csv": [".csv"] } }]
+    });
+    const writableFileStream = await fileHandle.createWritable();
+    let iterator = 0;
+    let totalRowsLoaded = 0;
+    const encoder = new TextEncoder();
+    const messaging = new BroadcastChannel(BROADCAST_CHANNEL_NAME);
+    const readable = new ReadableStream({
+      pull: async (controller) => {
+        try {
+          const response = await params.getNextPage(iterator++);
+          const safeRows = Array.isArray(response.rows) ? response?.rows : [];
+          const safeTotal = response.total ?? 0;
+          const isRowsEmpty = !safeRows || !safeRows.length;
+          totalRowsLoaded = isRowsEmpty ? safeTotal : totalRowsLoaded += safeRows.length;
+          const isFinished = totalRowsLoaded >= safeTotal;
+          if (isRowsEmpty) {
+            messaging.postMessage(
+              JSON.stringify({
+                type: "done",
+                total: safeTotal,
+                loadedItemsCount: totalRowsLoaded
+              })
+            );
+            await this.workerManager.triggerWorker({ id: iterator, type: "completed" });
+            messaging.close();
+            controller.close();
+            return;
+          }
+          const csvChunks = await this.workerManager.triggerWorker({
+            id: iterator,
+            type: "to_csv_chunk",
+            data: safeRows,
+            columns: params.columns
+          });
+          messaging.postMessage(
+            JSON.stringify({
+              type: "progress",
+              total: safeTotal,
+              loadedItemsCount: totalRowsLoaded
+            })
+          );
+          controller.enqueue(encoder.encode(csvChunks));
+          if (isFinished) {
+            messaging.postMessage(
+              JSON.stringify({
+                type: "done",
+                total: safeTotal,
+                loadedItemsCount: totalRowsLoaded
+              })
+            );
+            await this.workerManager.triggerWorker({ id: iterator, type: "completed" });
+            messaging.close();
+            controller.close();
+            return;
+          }
+        } catch (error) {
+          controller.error(error);
+          messaging.postMessage(
+            JSON.stringify({
+              type: "failed",
+              total: 0,
+              loadedItemsCount: totalRowsLoaded
+            })
+          );
+        }
+      }
+    });
+    try {
+      await readable.pipeTo(writableFileStream);
+    } catch (err) {
+      console.error("Export failed:", err);
+      throw err;
+    } finally {
+      this.workerManager.terminate();
+    }
+    return {
+      finished: true,
+      totalRowsLoaded,
+      logs: {
+        warnings: []
+      }
+    };
+  }
+};
+var FsAccessExportStrategy_default = FsAccessExportStrategy;
+
+// src/core/fabric/ExportControlFabric.ts
+var ExportControlFabric = class {
+  static create() {
+    const controller = new ExportController({
+      fsAccessStrategy: new FsAccessExportStrategy_default(),
+      blobExportStrategy: new BolbExportStrategy_default()
+    });
+    return controller;
+  }
+};
+
+// src/core/ExportControllerSingleton.ts
+var _ExportControllerSingleton = class _ExportControllerSingleton {
+  static init() {
+    if (_ExportControllerSingleton.instance) {
+      return _ExportControllerSingleton.instance;
+    }
+    _ExportControllerSingleton.instance = ExportControlFabric.create();
+    _ExportControllerSingleton.initialized = true;
+    return _ExportControllerSingleton.instance;
+  }
+  static getInstance() {
+    if (!_ExportControllerSingleton.instance) {
+      return _ExportControllerSingleton.init();
+    }
+    return _ExportControllerSingleton.instance;
+  }
+};
+_ExportControllerSingleton.instance = null;
+_ExportControllerSingleton.initialized = false;
+var ExportControllerSingleton = _ExportControllerSingleton;
+var ExportControllerSingleton_default = ExportControllerSingleton;
+
+// src/hooks/useExportCSV.ts
+function useExportCSV() {
+  const exportCallbackRef = useRef(ExportControllerSingleton_default.init());
+  return {
+    handler: exportCallbackRef.current
+  };
+}
+var useExportCSV_default = useExportCSV;
+
+// src/hooks/useMessageExportCSV.ts
+import { useEffect } from "react";
+function useMessageExportCSV(cb) {
+  useEffect(() => {
+    const channel = new BroadcastChannel(BROADCAST_CHANNEL_NAME);
+    channel.addEventListener("message", (params) => {
+      try {
+        const json = JSON.parse(params.data);
+        cb(json);
+      } catch (error) {
+        console.error({ error });
+      }
+    });
+    return () => {
+      channel.close();
+    };
+  }, []);
+}
+var useMessageExportCSV_default = useMessageExportCSV;
+export {
+  useExportCSV_default as useExportCSV,
+  useMessageExportCSV_default as useMessageExportCSV
+};

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "react-csv-autopilot",
+  "version": "0.0.1-beta.2",
+  "description": "React hooks for CSV export with automatic pagination - drop the function, we handle the rest",
+  "author": "Pavlo Kuzina",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "peerDependencies": {
+    "react": "^18 || ^19"
+  },
+  "devDependencies": {
+    "@types/react": "^18",
+    "@types/wicg-file-system-access": "^2023.10.7",
+    "react": "^19.2.3",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PashaSchool/utils-kit.git",
+    "directory": "packages/react-csv-autopilot"
+  },
+  "bugs": {
+    "url": "https://github.com/PashaSchool/utils-kit/issues"
+  },
+  "homepage": "https://github.com/PashaSchool/utils-kit/blob/main/packages/react-csv-autopilot/README.md",
+  "keywords": [
+    "react",
+    "csv",
+    "export",
+    "hooks",
+    "autopilot",
+    "pagination",
+    "streaming",
+    "typescript",
+    "download",
+    "file-export",
+    "web-workers",
+    "progress-tracking",
+    "file-system-access",
+    "large-datasets",
+    "data-export"
+  ]
+}