Spatie Simple Excel

https://github.com/spatie/simple-excel
Admin
A PHP package that enables reading and writing simple Excel and CSV files with low memory usage...
Tokens:33,634
Snippets:429
Trust Score:10
License:MIT
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install Simple Excel

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Install the package via composer.

```bash
composer require spatie/simple-excel
```

--------------------------------

### Usage examples for streamDownload()

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelWriter.md

Demonstrates simple browser streaming and advanced usage with a callback for processing large datasets.

```php
// Simple streaming
$writer = SimpleExcelWriter::streamDownload('users-export.xlsx')
    ->addRow(['name' => 'John', 'email' => 'john@example.com'])
    ->toBrowser();

// With custom callback for large datasets
$writer = SimpleExcelWriter::streamDownload('users-export.xlsx', writerCallback: function ($writerCallback, $downloadName) {
    $writerCallback->openToBrowser($downloadName);
    
    foreach (User::all() as $user) {
        $writerCallback->addRow(['name' => $user->name, 'email' => $user->email]);
    }
});

$writer->toBrowser();
```

--------------------------------

### Apply Header Style

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/types.md

Example of configuring a style object and applying it to the writer header.

```php
use OpenSpout\Common\Entity\Style\Color;
use OpenSpout\Common\Entity\Style\Style;

$style = (new Style())
    ->setFontBold()
    ->setFontSize(12)
    ->setFontColor(Color::WHITE)
    ->setBackgroundColor(Color::BLUE);

$writer->setHeaderStyle($style);
```

--------------------------------

### Usage examples for create()

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelWriter.md

Demonstrates basic file creation, custom CSV delimiters, and configuring underlying OpenSpout writer options.

```php
use Spatie\SimpleExcel\SimpleExcelWriter;

// Basic usage
$writer = SimpleExcelWriter::create('export.xlsx')
    ->addRow(['name' => 'John', 'email' => 'john@example.com']);

// With custom delimiter
$writer = SimpleExcelWriter::create('export.csv', delimiter: ';');

// Configure the underlying writer
$writer = SimpleExcelWriter::create(
    file: 'export.xlsx',
    configureWriter: function ($writer) {
        $options = $writer->getOptions();
        $options->DEFAULT_COLUMN_WIDTH = 25;
        $options->DEFAULT_ROW_HEIGHT = 15;
    }
);
```

--------------------------------

### Usage example for createWithoutBom()

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelWriter.md

Initializes a CSV writer specifically configured to omit the BOM.

```php
$writer = SimpleExcelWriter::createWithoutBom('export.csv');
```

--------------------------------

### Read CSV Content

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Example CSV content structure.

```csv
email,first_name
john@example.com,john
jane@example.com,jane
```

--------------------------------

### Add Row with Style

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/types.md

Example of creating a row with a specific style and adding it to the writer.

```php
use OpenSpout\Common\Entity\Row;
use OpenSpout\Common\Entity\Style\Style;

$style = new Style();
$row = Row::fromValues(['John', 'Doe'], $style);
$writer->addRow($row);
```

--------------------------------

### Represent Row Data Examples

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/types.md

Examples of associative and numeric row structures, including mixed data types.

```php
// With headers (associative array)
['email' => 'john@example.com', 'first_name' => 'John', 'last_name' => 'Doe']

// Without headers (numeric array)
[0 => 'john@example.com', 1 => 'John', 2 => 'Doe']

// Mixed types
['name' => 'John', 'age' => 30, 'created_at' => DateTimeImmutable(...)]
```

--------------------------------

### Limit and skip rows

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Control the number of rows read or the starting position using take and skip methods.

```php
// $rows is an instance of Illuminate\Support\LazyCollection
$rows = SimpleExcelReader::create($pathToCsv)
    ->take(5)
    ->getRows();
```

```php
$rows = SimpleExcelReader::create($pathToCsv)
    ->skip(10)
    ->take(5)
    ->getRows();
```

--------------------------------

### Instantiate and configure a reader with ReaderFactory

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/ReaderFactory.md

Demonstrates creating an XLSX reader with custom date formatting options and iterating through its contents.

```php
use Spatie"));
use OpenSpout\Reader\CSV\Options as CSVOptions;
use OpenSpout\Reader\XLSX\Options as XLSXOptions;

// Configure XLSX reader
$xlsxOptions = new XLSXOptions();
$xlsxOptions->SHOULD_FORMAT_DATES = true;
$reader = ReaderFactory::createFromFile('data.xlsx', $xlsxOptions);
$reader->open('data.xlsx');

// Use the reader directly (advanced)
foreach ($reader->getSheetIterator() as $sheet) {
    foreach ($sheet->getRowIterator() as $row) {
        // Process row
    }
}

$reader->close();
```

--------------------------------

### Retrieve Header Row

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Get the header row as an array.

```php
$headers = SimpleExcelReader::create($pathToCsv)->getHeaders();

// $headers will contain
// [ 'email', 'first_name' ]
```

--------------------------------

### Create Writer Instances via createFromFile

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/WriterFactory.md

Instantiate a writer by automatically detecting the format from the file extension, optionally passing configuration objects.

```php
use Spatie\SimpleExcel\WriterFactory;
use OpenSpout\Writer\CSV\Options as CSVOptions;

// Create CSV writer with default options
$writer = WriterFactory::createFromFile('export.csv');

// Create XLSX writer
$writer = WriterFactory::createFromFile('export.xlsx');

// Create CSV writer with custom delimiter
$csvOptions = new CSVOptions();
$csvOptions->FIELD_DELIMITER = ';';
$writer = WriterFactory::createFromFile('export.csv', $csvOptions);
```

--------------------------------

### Running tests

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Execute the project test suite.

```bash
composer test
```

--------------------------------

### Create SimpleExcelReader instances

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/configuration.md

Initialize a reader by providing a file path, with an optional type override to skip auto-detection.

```php
// Auto-detect from extension
$reader = SimpleExcelReader::create('data.xlsx');

// Explicitly specify type (skips extension detection)
$reader = SimpleExcelReader::create('/path/to/file', 'csv');
```

--------------------------------

### Configure reader method chaining

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/configuration.md

Demonstrates a logical sequence for configuring reader settings before retrieving rows.

```php
SimpleExcelReader::create('data.xlsx')
    ->fromSheet(1)                        // Select sheet first
    ->headerOnRow(2)                      // Set header location
    ->trimHeaderRow()                     // Clean headers
    ->headersToSnakeCase()                // Transform headers
    ->trimValues()                        // Clean values
    ->formatValuesUsing(...)              // Format values
    ->skip(5)                             // Pagination
    ->take(100)
    ->getRows();
```

--------------------------------

### Getting the number of rows written

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Retrieve the total row count, including the header row, using getNumberOfRows.

```php
$writerWithAutomaticHeader = SimpleExcelWriter::create($this->pathToCsv)
    ->addRow([
        'first_name' => 'John',
        'last_name' => 'Doe',
    ]);

$writerWithAutomaticHeader->getNumberOfRows(); // returns 2
```

--------------------------------

### Create reader from file path

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/ReaderFactory.md

Instantiate a reader by automatically detecting the file format from the extension. Supports optional configuration objects for specific reader types.

```php
public static function createFromFile(
    string $path,
    CSVOptions|XLSXOptions|ODSOptions|null $options = null
): ReaderInterface
```

```php
use Spatie\SimpleExcel\ReaderFactory;
use OpenSpout\Reader\CSV\Options as CSVOptions;

// Create CSV reader with default options
$reader = ReaderFactory::createFromFile('data.csv');

// Create XLSX reader with custom options
$reader = ReaderFactory::createFromFile('data.xlsx');

// Create CSV reader with configuration
$csvOptions = new CSVOptions();
$csvOptions->FIELD_DELIMITER = ';';
$reader = ReaderFactory::createFromFile('data.csv', $csvOptions);
```

--------------------------------

### Configure reader with fluent interface

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/README.md

Chain configuration methods to process data during the reading phase.

```php
$rows = SimpleExcelReader::create('data.csv')
    ->trimHeaderRow()
    ->headersToSnakeCase()
    ->trimValues()
    ->skip(10)
    ->take(100)
    ->getRows();
```

--------------------------------

### Specify header row location

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Use headerOnRow to define the line number where headers start, ignoring preceding content.

```php
// $rows is an instance of Illuminate\Support\LazyCollection
$rows = SimpleExcelReader::create($pathToCsv)
    ->trimHeaderRow()
    ->headerOnRow(3)
    ->getRows()
    ->each(function(array $rowProperties) {
       // in the first pass $rowProperties will contain
       // ['email' => 'john@example', 'first_name' => 'john']
});
```

--------------------------------

### SimpleExcelReader::create()

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelReader.md

Creates a new instance of SimpleExcelReader to process a specified file.

```APIDOC
## SimpleExcelReader::create()

### Description
Creates a new instance of SimpleExcelReader. This is the primary factory method for initializing the reader.

### Signature
`public static function create(string $file, string $type = ''): static`

### Parameters
- **file** (string) - Required - Path to the file to read (.csv or .xlsx)
- **type** (string) - Optional - Explicit type ('csv', 'xlsx', 'ods'). If empty, detected from file extension

### Returns
- **static** - A new SimpleExcelReader instance

### Throws
- **OpenSpout\Common\Exception\UnsupportedTypeException** - When file extension or type is not supported

### Example
```php
use Spatie\SimpleExcel\SimpleExcelReader;

// Auto-detect format from extension
$reader = SimpleExcelReader::create('data.xlsx');

// Explicitly specify type
$reader = SimpleExcelReader::create('data', 'csv');
```
```

--------------------------------

### Create SimpleExcelWriter instances

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelWriter.md

Defines the method signature for initializing a new writer instance for file-based output.

```php
public static function create(
    string $file,
    string $type = '',
    ?callable $configureWriter = null,
    ?string $delimiter = null,
    ?bool $shouldAddBom = null,
): static
```

--------------------------------

### Fluent method chaining for data processing

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelReader.md

Demonstrates configuring the reader and processing rows using a chainable interface.

```php
$rows = SimpleExcelReader::create('report.xlsx')
    ->fromSheet(2)
    ->headerOnRow(3)
    ->trimHeaderRow()
    ->headersToSnakeCase()
    ->trimValues()
    ->formatValuesUsing(function ($value, $key) {
        if ($key === 'email') return strtolower($value);
        return $value;
    })
    ->skip(5)
    ->take(100)
    ->getRows();

$rows->each(function ($row) {
    // Process row
});
```

--------------------------------

### Configure Column Widths

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/usage-patterns.md

Sets specific column widths for Excel files using a configuration callback.

```php
SimpleExcelWriter::create(
    file: 'users.xlsx',
    configureWriter: function ($writer) {
        $options = $writer->getOptions();
        $options->DEFAULT_COLUMN_WIDTH = 20;
        $options->setColumnWidth(40, 1);        // Column A (Name) = 40 wide
        $options->setColumnWidthForRange(15, 2, 3); // Columns B-C = 15 wide
    }
)
->addRows(User::all()->map(fn($u) => [
    'name' => $u->name,
    'email' => $u->email,
    'phone' => $u->phone,
])->toArray());
```

--------------------------------

### Initialize SimpleExcelWriter

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelWriter.md

The constructor is protected and typically called via static factory methods.

```php
protected function __construct(
    private string $path,
    string $type = '',
    ?string $delimiter = null,
    ?bool $shouldAddBom = null,
)
```

--------------------------------

### Apply type-specific configuration

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/configuration.md

Adjust reader settings dynamically based on the file extension.

```php
$file = 'data.csv';
$extension = strtolower(pathinfo($file, PATHINFO_EXTENSION));

$reader = SimpleExcelReader::create($file);

if ($extension === 'csv') {
    $reader->useDelimiter(';')
           ->useEncoding('ISO-8859-1');
} elseif ($extension === 'xlsx') {
    $reader->preserveDateTimeFormatting()
           ->preserveEmptyRows();
}

$rows = $reader->getRows();
```

--------------------------------

### Create reader from MIME type

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/ReaderFactory.md

Instantiate a reader by detecting the file format from the provided MIME type.

```php
public static function createFromFileByMimeType(
    string $path,
    CSVOptions|XLSXOptions|ODSOptions|null $options = null
): ReaderInterface
```

```php
use Spatie\SimpleExcel\ReaderFactory;

$reader = ReaderFactory::createFromFileByMimeType('data.xlsx');
```

--------------------------------

### WriterFactory::createFromFile()

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/WriterFactory.md

Creates a writer instance by automatically detecting the file format from the file extension.

```APIDOC
## WriterFactory::createFromFile()

### Description
Creates a writer instance by automatically detecting the file format from the file extension (.csv, .xlsx, or .ods).

### Signature
`public static function createFromFile(string $path, CSVOptions|XLSXOptions|ODSOptions|null $options = null): WriterInterface`

### Parameters
- **path** (string) - Required - Path where the file will be written.
- **options** (CSVOptions|XLSXOptions|ODSOptions|null) - Optional - Configuration options for the writer type.

### Returns
- **WriterInterface** - A writer instance for the detected file type.

### Throws
- **UnsupportedTypeException** - When file extension is not recognized.
```

--------------------------------

### Configure Writer Callback

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/types.md

Allows direct configuration of the underlying OpenSpout WriterInterface instance. Used within SimpleExcelWriter::create().

```php
SimpleExcelWriter::create(
    file: 'export.xlsx',
    configureWriter: function ($writer) {
        $options = $writer->getOptions();
        $options->DEFAULT_COLUMN_WIDTH = 25;
        $options->setColumnWidth(50, 1); // Column A = 50 wide
    }
);
```

--------------------------------

### Adding layout and styles

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Apply styles to rows or headers using the OpenSpout Style builder. Styles are only applicable to Excel documents.

```php
use OpenSpout\Common\Entity\Style\Color;
use OpenSpout\Common\Entity\Style\CellAlignment;
use OpenSpout\Common\Entity\Style\Style;
use OpenSpout\Common\Entity\Style\Border;
use OpenSpout\Common\Entity\Style\BorderPart;

/* Create a border around a cell */
$border = new Border(
        new BorderPart(Border::BOTTOM, Color::LIGHT_BLUE, Border::WIDTH_THIN, Border::STYLE_SOLID),
        new BorderPart(Border::LEFT, Color::LIGHT_BLUE, Border::WIDTH_THIN, Border::STYLE_SOLID),
        new BorderPart(Border::RIGHT, Color::LIGHT_BLUE, Border::WIDTH_THIN, Border::STYLE_SOLID),
        new BorderPart(Border::TOP, Color::LIGHT_BLUE, Border::WIDTH_THIN, Border::STYLE_SOLID)
    );

$style = (new Style())
   ->setFontBold()
   ->setFontSize(15)
   ->setFontColor(Color::BLUE)
   ->setShouldWrapText()
   ->setBackgroundColor(Color::YELLOW)
   ->setBorder($border);

$writer->addRow(['values', 'of', 'the', 'row'], $style);
```

```php
$writer->setHeaderStyle($style);
```

--------------------------------

### Handle Import Errors with Try-Catch

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/usage-patterns.md

Wraps file reading in a try-catch block to handle IO, format, and validation exceptions gracefully.

```php
try {
    SimpleExcelReader::create('users.csv')
        ->getRows()
        ->each(function ($row) {
            if (!filter_var($row['email'], FILTER_VALIDATE_EMAIL)) {
                throw new Exception("Invalid email: {$row['email']}");
            }
            User::create($row);
        });
} catch (IOException $e) {
    logger()->error("File error: " . $e->getMessage());
} catch (UnsupportedTypeException $e) {
    logger()->error("Unsupported file format: " . $e->getMessage());
} catch (Exception $e) {
    logger()->error("Import error: " . $e->getMessage());
}
```

--------------------------------

### Implementing a Robust Excel Processing Pipeline in PHP

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/errors.md

Uses try-catch blocks to handle file existence, unsupported types, and I/O exceptions during row processing.

```php
use OpenSpout\Common\Exception\UnsupportedTypeException;
use OpenSpout\Common\Exception\IOException;

function processExcelFile($filePath) {
    try {
        // Check file exists
        if (!file_exists($filePath)) {
            throw new Exception("File not found: $filePath");
        }
        
        // Create reader
        $reader = SimpleExcelReader::create($filePath);
        
        // Process rows
        $reader->getRows()
            ->filter(fn($row) => !empty($row['email']))
            ->each(function ($row) {
                try {
                    validateAndSaveRow($row);
                } catch (Exception $e) {
                    logError("Row error: " . $e->getMessage(), $row);
                }
            });
            
        $reader->close();
        
    } catch (UnsupportedTypeException $e) {
        logError("Unsupported file format: " . $e->getMessage());
        return false;
        
    } catch (IOException $e) {
        logError("File I/O error: " . $e->getMessage());
        return false;
        
    } catch (Exception $e) {
        logError("Unexpected error: " . $e->getMessage());
        return false;
    }
    
    return true;
}
```

--------------------------------

### Enable Exception Stack Traces in PHP

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/errors.md

Use a try-catch block to capture and display detailed error messages and stack traces when creating a reader instance.

```php
try {
    $reader = SimpleExcelReader::create($file);
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
    echo "Stack trace:\n" . $e->getTraceAsString();
}
```

--------------------------------

### Batch Import with Progress

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/usage-patterns.md

Process large files in chunks to manage memory usage and track progress.

```php
$total = 0;
$batch = [];
$batchSize = 1000;

SimpleExcelReader::create('large-users.csv')->getRows()
    ->each(function ($row) use (&$batch, &$total, $batchSize) {
        $batch[] = $row;
        
        if (count($batch) >= $batchSize) {
            User::insert($batch);
            $total += count($batch);
            $batch = [];
            
            echo "Processed: $total rows\n";
        }
    });

// Insert remaining rows
if (!empty($batch)) {
    User::insert($batch);
    $total += count($batch);
}

echo "Total imported: $total rows\n";
```

--------------------------------

### Basic CSV export

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelWriter.md

Create a simple CSV file and add rows using the fluent interface.

```php
SimpleExcelWriter::create('users.csv')
    ->addRow(['name' => 'John', 'email' => 'john@example.com'])
    ->addRow(['name' => 'Jane', 'email' => 'jane@example.com']);
```

--------------------------------

### Set Custom Headers

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Manually define headers using useHeaders().

```php
// $rows is an instance of Illuminate\Support\LazyCollection
$rows = SimpleExcelReader::create($pathToCsv)
    ->useHeaders(['email_address', 'given_name'])
    ->getRows()
    ->each(function(array $rowProperties) {
       // in the first pass $rowProperties will contain
       // ['email_address' => 'john@example', 'given_name' => 'john']
});
```

--------------------------------

### Import data with transformation

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/usage-patterns.md

Clean and format data during the import process using trimValues and formatValuesUsing.

```php
SimpleExcelReader::create('users.csv')
    ->trimValues()                    // Clean whitespace
    ->formatValuesUsing(function ($value, $key) {
        if ($key === 'email') return strtolower($value);
        if ($key === 'name') return ucwords($value);
        return $value;
    })
    ->getRows()
    ->each(fn($row) => User::create($row));
```

--------------------------------

### Create Writer Instances via createFromType

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/WriterFactory.md

Instantiate a writer by explicitly specifying the file type. This method is deprecated in favor of createFromFile.

```php
use Spatie\SimpleExcel\WriterFactory;

$writer = WriterFactory::createFromType('csv');
$writer = WriterFactory::createFromType('xlsx');
$writer = WriterFactory::createFromType('ods');
```

--------------------------------

### Catching IOException in SimpleExcel

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/errors.md

Demonstrates how to wrap file reading operations in a try-catch block to handle potential IOExceptions.

```php
use OpenSpout\Common\Exception\IOException;
use Spatie\SimpleExcel\SimpleExcelReader;

try {
    $rows = SimpleExcelReader::create('nonexistent.csv')->getRows();
} catch (IOException $e) {
    echo "File error: " . $e->getMessage();
    // Message: "Could not open nonexistent.csv for reading! File does not exist."
}
```

--------------------------------

### Create Workbook with Multiple Sheets

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/usage-patterns.md

Use SimpleExcelWriter to create a file and add multiple sheets sequentially. Ensure close() is called to finalize the file.

```php
$writer = SimpleExcelWriter::create('report.xlsx');

// First sheet: Summary
$writer->nameCurrentSheet('Summary');
$writer->addRow(['metric' => 'Total Users', 'value' => User::count()]);
$writer->addRow(['metric' => 'Total Orders', 'value' => Order::count()]);

// Second sheet: Users
$writer->addNewSheetAndMakeItCurrent('Users');
$writer->addRows(
    User::all()->map(fn($u) => [
        'name' => $u->name,
        'email' => $u->email,
    ])->toArray()
);

// Third sheet: Orders
$writer->addNewSheetAndMakeItCurrent('Orders');
$writer->addRows(
    Order::all()->map(fn($o) => [
        'id' => $o->id,
        'total' => $o->total,
        'status' => $o->status,
    ])->toArray()
);

$writer->close();
```

--------------------------------

### toBrowser()

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelWriter.md

Finalizes the file and streams it to the browser, triggering a download. Note that this method calls exit, terminating the script.

```APIDOC
## toBrowser()

### Description
Finalize the file and stream it to the browser, triggering a download. This method closes the file and calls exit, so no further code will execute.

### Signature
`public function toBrowser()`

### Returns
- **void** - Terminates the script execution.
```

--------------------------------

### Set headers manually

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Define custom headers instead of relying on automatic detection.

```php
use Spatie\SimpleExcel\SimpleExcelWriter;

$writer = SimpleExcelWriter::create($pathToCsv)
    ->addHeader(['first_name', 'last_name'])
    ->addRow(['John', 'Doe'])
    ->addRow(['Jane', 'Doe'])
```

--------------------------------

### Manually working with the writer object

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Access the underlying OpenSpout writer instance via getWriter.

```php
$writer = SimpleExcelWriter::create($pathToCsv)->getWriter();
```

--------------------------------

### Advanced Writer Configuration and Usage

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/WriterFactory.md

Configure writers with specific options and perform manual file operations for advanced scenarios.

```php
use Spatie\SimpleExcel\WriterFactory;
use OpenSpout\Writer\CSV\Options as CSVOptions;
use OpenSpout\Writer\XLSX\Options as XLSXOptions;

// Configure CSV writer with semicolon delimiter
$csvOptions = new CSVOptions();
$csvOptions->FIELD_DELIMITER = ';';
$csvOptions->SHOULD_ADD_BOM = false;
$writer = WriterFactory::createFromFile('export.csv', $csvOptions);

// Configure XLSX writer with custom column widths
$xlsxOptions = new XLSXOptions();
$xlsxOptions->DEFAULT_COLUMN_WIDTH = 25;
$writer = WriterFactory::createFromFile('export.xlsx', $xlsxOptions);

// Use the writer directly (advanced)
$writer->openToFile('export.xlsx');
$writer->addRow(\OpenSpout\Common\Entity\Row::fromValues(['Name', 'Email']));
$writer->addRow(\OpenSpout\Common\Entity\Row::fromValues(['John', 'john@example.com']));
$writer->close();
```

--------------------------------

### Select Sheet by Name

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/configuration.md

Specify the sheet to read using its name.

```php
SimpleExcelReader::create('workbook.xlsx')
    ->fromSheetName('Users')
    ->getRows();
```

--------------------------------

### useHeaders()

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelReader.md

Manually specify headers for the dataset instead of reading them from the file.

```APIDOC
## useHeaders(array $headers)

### Description
Manually specify headers instead of reading them from the file.

### Method
public function useHeaders(array $headers): self

### Parameters
- **headers** (array) - Required - Array of header names to use

### Returns
self — Fluent interface for method chaining
```

--------------------------------

### Setting column widths and row heights

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Configure writer options via the configureWriter callback to adjust dimensions.

```php
SimpleExcelWriter::create(
    file: 'document.xlsx',
    configureWriter: function ($writer) {
        $options = $writer->getOptions();
        $options->DEFAULT_COLUMN_WIDTH=25; // set default width
        $options->DEFAULT_ROW_HEIGHT=15; // set default height
        // set columns 1, 3 and 8 to width 40
        $options->setColumnWidth(40, 1, 3, 8);
        // set columns 9 through 12 to width 10
        $options->setColumnWidthForRange(10, 9, 12);
    }
)
```

--------------------------------

### Stream Download Callback

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/types.md

Provides a callback for handling stream downloads via the OpenSpout WriterInterface. Used with SimpleExcelWriter::streamDownload().

```php
SimpleExcelWriter::streamDownload('export.xlsx', writerCallback: function ($writer, $downloadName) {
    $writer->openToBrowser($downloadName);
    
    foreach ($users as $user) {
        $writer->addRow(\OpenSpout\Common\Entity\Row::fromValues([
            $user->name,
            $user->email,
        ]));
    }
});
```

--------------------------------

### Creating additional sheets

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Use addNewSheetAndMakeItCurrent to switch to a new sheet during the writing process.

```php
$writer = SimpleExcelWriter::create($pathToXlsx);

Posts::all()->each(function (Post $post) use ($writer) {
    $writer->nameCurrentSheet($post->title);

    $post->comments->each(function (Comment $comment) use ($writer) {
        $writer->addRow([
            'comment' => $comment->comment,
            'author' => $comment->author,
        ]);
    });

    if(!$post->is($posts->last())) {
        $writer->addNewSheetAndMakeItCurrent();
    }
});
```

--------------------------------

### Handle Files Without Headers in PHP

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/usage-patterns.md

Configures the reader to ignore existing headers and apply a custom set of column names.

```php
SimpleExcelReader::create('data.csv')
    ->noHeaderRow()
    ->useHeaders(['email', 'first_name', 'last_name'])
    ->getRows()
    ->each(fn($row) => User::create($row));
```

--------------------------------

### Export data with custom styling

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/README.md

Apply OpenSpout styles to headers before writing data rows.

```php
use OpenSpout\Common\Entity\Style\{Color, Style};

$headerStyle = (new Style())
    ->setFontBold()
    ->setBackgroundColor(Color::BLUE)
    ->setFontColor(Color::WHITE);

SimpleExcelWriter::create('users.xlsx')
    ->setHeaderStyle($headerStyle)
    ->addRows(User::all()->map(fn($u) => [
        'name' => $u->name,
        'email' => $u->email,
    ])->toArray());
```

--------------------------------

### Write data to a file

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Create a new file and add rows using the SimpleExcelWriter.

```php
use Spatie\SimpleExcel\SimpleExcelWriter;

$writer = SimpleExcelWriter::create($pathToCsv)
     ->addRow([
        'first_name' => 'John',
        'last_name' => 'Doe',
    ])
    ->addRow([
        'first_name' => 'Jane',
        'last_name' => 'Doe',
    ]);
```

```csv
first_name,last_name
John,Doe
Jane,Doe
```

--------------------------------

### Import specific columns

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/usage-patterns.md

Use map to select and rename columns before processing the data.

```php
SimpleExcelReader::create('users.csv')
    ->getRows()
    ->map(fn($row) => [
        'email' => $row['email'],
        'first_name' => $row['first_name'],
        // Ignore other columns
    ])
    ->each(fn($row) => User::create($row));
```

--------------------------------

### Compare Two Files

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/usage-patterns.md

Identify unique records by comparing two files using a HashSet.

```php
$existingEmails = new HashSet();

SimpleExcelReader::create('existing-users.csv')
    ->getRows()
    ->each(fn($row) => $existingEmails->add($row['email']));

$newUsers = [];

SimpleExcelReader::create('new-users.csv')
    ->getRows()
    ->filter(fn($row) => !$existingEmails->contains($row['email']))
    ->each(function ($row) use (&$newUsers) {
        $newUsers[] = $row;
    });

User::insert($newUsers);
```

--------------------------------

### Disable BOM

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Use createWithoutBom to initialize a writer without a Byte Order Mark.

```php
SimpleExcelWriter::createWithoutBom($this->pathToCsv, $type);
```

--------------------------------

### Excel export with styling

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelWriter.md

Apply custom styles to headers using OpenSpout style entities.

```php
use OpenSpout\Common\Entity\Style\Color;
use OpenSpout\Common\Entity\Style\Style;

$headerStyle = (new Style())
    ->setFontBold()
    ->setBackgroundColor(Color::LIGHT_BLUE);

SimpleExcelWriter::create('users.xlsx')
    ->setHeaderStyle($headerStyle)
    ->addRows([
        ['name' => 'John', 'email' => 'john@example.com'],
        ['name' => 'Jane', 'email' => 'jane@example.com'],
    ]);
```

--------------------------------

### Batch Process Import with Queues

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/usage-patterns.md

Chunks large files and dispatches individual rows to a queue for background processing.

```php
namespace App\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Queue\SerializesModels;
use Spatie\SimpleExcel\SimpleExcelReader;

class ProcessExcelImport implements ShouldQueue
{
    use Queueable, SerializesModels;
    
    public function __construct(private string $filePath) {}
    
    public function handle()
    {
        SimpleExcelReader::create($this->filePath)
            ->getRows()
            ->chunk(1000)
            ->each(function ($chunk) {
                foreach ($chunk as $row) {
                    ProcessExcelRow::dispatch($row);
                }
            });
    }
}
```

--------------------------------

### Writer Configuration Callback

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/types.md

A callback used to configure the underlying OpenSpout writer instance.

```APIDOC
## Writer Configuration Callback

### Signature
`callable(WriterInterface $writer): void`

### Description
Used by `SimpleExcelWriter::create()` via the `configureWriter` parameter to modify writer options.

### Parameters
- `$writer` (WriterInterface) - The underlying OpenSpout WriterInterface instance.

### Returns
- (void)

### Example
```php
SimpleExcelWriter::create(
    file: 'export.xlsx',
    configureWriter: function ($writer) {
        $options = $writer->getOptions();
        $options->DEFAULT_COLUMN_WIDTH = 25;
        $options->setColumnWidth(50, 1); // Column A = 50 wide
    }
);
```
```

--------------------------------

### ReaderFactory::createFromFile

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/ReaderFactory.md

Creates a reader instance for a specified file path with optional configuration settings.

```APIDOC
## ReaderFactory::createFromFile

### Description
Creates a reader instance for the specified file. This method is used to initialize a reader with format-specific options.

### Signature
`ReaderFactory::createFromFile(string $path, ?Options $options = null)`

### Parameters
- **$path** (string) - Required - The path to the file to be read.
- **$options** (Options) - Optional - Configuration object specific to the file type (CSV, XLSX, or ODS).

### Supported Options
- **CSV Options** (`OpenSpout\Reader\CSV\Options`): FIELD_DELIMITER, FIELD_ENCLOSURE, ENCODING
- **XLSX Options** (`OpenSpout\Reader\XLSX\Options`): SHOULD_FORMAT_DATES, SHOULD_PRESERVE_EMPTY_ROWS
- **ODS Options** (`OpenSpout\Reader\ODS\Options`): Configuration for ODS files

### Example
```php
use Spatie\SimpleExcel\ReaderFactory;
use OpenSpout\Reader\XLSX\Options as XLSXOptions;

$xlsxOptions = new XLSXOptions();
$xlsxOptions->SHOULD_FORMAT_DATES = true;
$reader = ReaderFactory::createFromFile('data.xlsx', $xlsxOptions);
```
```

--------------------------------

### Take rows

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelReader.md

Use take to limit the total number of rows returned.

```php
// Read first 100 rows
$rows = SimpleExcelReader::create('data.csv')
    ->take(100)
    ->getRows();
```

--------------------------------

### Log File Properties in PHP

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/errors.md

Inspect file metadata such as readability, size, and MIME type before processing to ensure the file is accessible.

```php
if (file_exists($file)) {
    $info = [
        'path' => $file,
        'exists' => true,
        'readable' => is_readable($file),
        'size' => filesize($file),
        'extension' => strtolower(pathinfo($file, PATHINFO_EXTENSION)),
        'mime' => mime_content_type($file),
    ];
    
    var_dump($info);
}
```

--------------------------------

### Stream download to browser with toBrowser()

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelWriter.md

Finalizes the file and triggers a browser download. Note that this method calls exit, terminating script execution.

```php
public function toBrowser()
```

```php
$writer = SimpleExcelWriter::streamDownload('export.xlsx')
    ->addRow(['name' => 'John', 'email' => 'john@example.com'])
    ->addRow(['name' => 'Jane', 'email' => 'jane@example.com']);

$writer->toBrowser(); // User downloads the file and script exits
```

--------------------------------

### SimpleExcelWriter::create()

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelWriter.md

Creates a new writer instance that writes to a file on disk. Supports CSV, XLSX, and ODS formats.

```APIDOC
## SimpleExcelWriter::create()

### Description
Creates a new writer instance that writes to a file on disk. The file type is detected from the extension or can be explicitly provided.

### Signature
`public static function create(string $file, string $type = '', ?callable $configureWriter = null, ?string $delimiter = null, ?bool $shouldAddBom = null): static`

### Parameters
- **file** (string) - Required - Path where the file will be written (.csv or .xlsx)
- **type** (string) - Optional - Explicit type ('csv', 'xlsx', 'ods')
- **configureWriter** (?callable) - Optional - Callback to configure the underlying OpenSpout writer
- **delimiter** (?string) - Optional - CSV-specific: field delimiter character
- **shouldAddBom** (?bool) - Optional - CSV-specific: whether to add BOM

### Returns
- **static** - A new SimpleExcelWriter instance
```

--------------------------------

### SimpleExcelWriter::streamDownload()

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelWriter.md

Creates a writer instance that streams output directly to the browser as a file download.

```APIDOC
## SimpleExcelWriter::streamDownload()

### Description
Creates a writer that streams output directly to the browser as a download.

### Signature
`public static function streamDownload(string $downloadName, string $type = '', ?callable $writerCallback = null, ?string $delimiter = null, ?bool $shouldAddBom = null): static`

### Parameters
- **downloadName** (string) - Required - Name of the file to download
- **type** (string) - Optional - Explicit type ('csv', 'xlsx', 'ods')
- **writerCallback** (?callable) - Optional - Callback for manual control of writing process
- **delimiter** (?string) - Optional - CSV-specific: field delimiter character
- **shouldAddBom** (?bool) - Optional - CSV-specific: whether to add BOM

### Returns
- **static** - A new SimpleExcelWriter instance for streaming
```

--------------------------------

### Create reader from explicit type

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/ReaderFactory.md

Instantiate a reader by explicitly specifying the file type. Note that this method is deprecated in favor of createFromFile().

```php
public static function createFromType(
    string $readerType,
    CSVOptions|XLSXOptions|ODSOptions|null $options = null
): ReaderInterface
```

```php
use Spatie\SimpleExcel\ReaderFactory;

$reader = ReaderFactory::createFromType('csv');
$reader = ReaderFactory::createFromType('xlsx');
$reader = ReaderFactory::createFromType('ods');
```

--------------------------------

### Accessing Sheets by 1-based Index in PHP

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/errors.md

Demonstrates the correct usage of 1-based sheet indexing to avoid InvalidArgumentException.

```php
// CORRECT: First sheet is index 1
$rows = SimpleExcelReader::create('workbook.xlsx')->fromSheet(1)->getRows();

// WRONG: Index 0 will throw InvalidArgumentException
$rows = SimpleExcelReader::create('workbook.xlsx')->fromSheet(0)->getRows(); // Error!
```

--------------------------------

### Catching UnsupportedTypeException

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/errors.md

Handle exceptions thrown when an unsupported file format is provided to the reader.

```php
use OpenSpout\Common\Exception\UnsupportedTypeException;
use Spatie\SimpleExcel\SimpleExcelReader;

try {
    $reader = SimpleExcelReader::create('data.pdf');
} catch (UnsupportedTypeException $e) {
    echo "Unsupported file format: " . $e->getMessage();
    // Message: "No readers supporting the given type: pdf"
}
```

--------------------------------

### Import Data via Laravel Command

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/usage-patterns.md

Implements a console command to import data from a file, utilizing updateOrCreate for data synchronization.

```php
namespace App\Console\Commands;

use Illuminate\Console\Command;
use Spatie\SimpleExcel\SimpleExcelReader;
use App\Models\User;

class ImportUsersCommand extends Command
{
    protected $signature = 'import:users {file}';
    
    public function handle()
    {
        $file = $this->argument('file');
        
        if (!file_exists($file)) {
            $this->error("File not found: $file");
            return 1;
        }
        
        $count = 0;
        
        SimpleExcelReader::create($file)
            ->headersToSnakeCase()
            ->getRows()
            ->each(function ($row) use (&$count) {
                User::updateOrCreate(
                    ['email' => $row['email']],
                    $row
                );
                $count++;
            });
        
        $this->info("Imported $count users");
        return 0;
    }
}
```

--------------------------------

### Synchronize Data

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/usage-patterns.md

Import data from a file and perform update-or-create operations in the database.

```php
// Import from file, update or create in database
SimpleExcelReader::create('users-updated.csv')
    ->trimValues()
    ->headersToSnakeCase()
    ->getRows()
    ->each(function ($row) {
        User::updateOrCreate(
            ['email' => $row['email']],
            ['name' => $row['name'], 'phone' => $row['phone']]
        );
    });
```

--------------------------------

### Retrieve file path with getPath()

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelWriter.md

Returns the file path currently being written to.

```php
public function getPath(): string
```

--------------------------------

### Format Headers Using Callbacks in PHP

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/configuration.md

Applies a custom transformation function to every header string.

```php
// Convert to lowercase
SimpleExcelReader::create('data.csv')
    ->formatHeadersUsing(fn($h) => strtolower($h))
    ->getRows();

// Convert to uppercase
SimpleExcelReader::create('data.csv')
    ->formatHeadersUsing(fn($h) => strtoupper($h))
    ->getRows();

// Add prefix
SimpleExcelReader::create('data.csv')
    ->formatHeadersUsing(fn($h) => "col_$h")
    ->getRows();
```

--------------------------------

### Write a CSV file

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/00-START-HERE.txt

Initializes a writer for a CSV file and appends rows using associative arrays.

```php
use Spatie\SimpleExcel\SimpleExcelWriter;
  
  SimpleExcelWriter::create('export.csv')
      ->addRow(['name' => 'John', 'email' => 'john@example.com'])
      ->addRow(['name' => 'Jane', 'email' => 'jane@example.com']);
```

--------------------------------

### Select Sheet by Index

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/configuration.md

Specify the sheet to read using a 1-based index.

```php
// Read the 2nd sheet
SimpleExcelReader::create('workbook.xlsx')
    ->fromSheet(2)
    ->getRows();
```

--------------------------------

### Stream download method signature

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelWriter.md

Defines the method signature for streaming file output directly to the browser.

```php
public static function streamDownload(
    string $downloadName,
    string $type = '',
    ?callable $writerCallback = null,
    ?string $delimiter = null,
    ?bool $shouldAddBom = null,
): static
```

--------------------------------

### Access underlying OpenSpout objects

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/README.md

Retrieve the raw OpenSpout reader or writer instances for advanced customization.

```php
$reader = SimpleExcelReader::create('data.xlsx')->getReader();
$writer = SimpleExcelWriter::create('export.xlsx')->getWriter();
```

--------------------------------

### Accessing the underlying OpenSpout writer

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelWriter.md

Use getWriter to access the underlying OpenSpout instance for advanced configuration like setting default column widths.

```php
$writer = SimpleExcelWriter::create('export.xlsx');
$openspoutWriter = $writer->getWriter();

// Access OpenSpout features
$options = $openspoutWriter->getOptions();
$options->DEFAULT_COLUMN_WIDTH = 25;
```

--------------------------------

### Import data with error recovery

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/usage-patterns.md

Use try-catch blocks within the iteration to log errors and continue processing remaining rows.

```php
$errorCount = 0;
$successCount = 0;

SimpleExcelReader::create('users.csv')->getRows()
    ->each(function ($row) use (&$errorCount, &$successCount) {
        try {
            User::create($row);
            $successCount++;
        } catch (Exception $e) {
            logger()->warning("Failed to import: {$row['email']} - {$e->getMessage()}");
            $errorCount++;
        }
    });

logger()->info("Import complete: $successCount successful, $errorCount failed");
```

--------------------------------

### Import large files efficiently

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/usage-patterns.md

Process large datasets in chunks to minimize memory usage during database insertion.

```php
// For files with millions of rows, use chunking
SimpleExcelReader::create('large-users.csv')
    ->getRows()
    ->chunk(1000)  // Process 1000 rows at a time
    ->each(function ($chunk) {
        // Insert chunk into database (more efficient than one-by-one)
        User::insert($chunk->toArray());
    });
```

--------------------------------

### Work with Multiple Sheets

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Methods for selecting and checking sheets in Excel documents.

```php
$rows = SimpleExcelReader::create($pathToXlsx)
    ->fromSheet(3)
    ->getRows();
```

```php
$sheets = SimpleExcelReader::create($pathToXlsx)
    ->getSheetNames();
```

```php
$rows = SimpleExcelReader::create($pathToXlsx)
    ->fromSheetName("sheet1")
    ->getRows();
```

```php
$hasSheet = SimpleExcelReader::create($pathToXlsx)
    ->hasSheet("sheet1");
```

--------------------------------

### Stream downloads to browser

Source: https://github.com/spatie/simple-excel/blob/main/README.md

Stream generated files directly to the browser, with support for large datasets and callbacks.

```php
$writer = SimpleExcelWriter::streamDownload('your-export.xlsx')
     ->addRow([
        'first_name' => 'John',
        'last_name' => 'Doe',
    ])
    ->addRow([
        'first_name' => 'Jane',
        'last_name' => 'Doe',
    ])
    ->toBrowser();
```

```php
$writer = SimpleExcelWriter::streamDownload('your-export.xlsx');

foreach (range(1, 10_000) as $i) {
    $writer->addRow([
        'first_name' => 'John',
        'last_name' => 'Doe',
    ]);

    if ($i % 1000 === 0) {
        flush(); // Flush the buffer every 1000 rows
    }
}

$writer->toBrowser();
```

```php
use Spatie\SimpleExcel\SimpleExcelWriter;
use OpenSpout\Common\Entity\Row;

$writer = SimpleExcelWriter::streamDownload('user-list.xlsx', function ($writerCallback, $downloadName) {

    $writerCallback->openToBrowser($downloadName);

    $writerCallback->addRow(Row::fromValues([
        'first_name' => 'First Name',
        'last_name' => 'Last Name',
    ]));

    $writerCallback->addRow(Row::fromValues([
        'first_name' => 'Rakib',
        'last_name' => 'Hossain',
    ]));

    foreach (range(1, 10_000) as $i) {
        $writerCallback->addRow(Row::fromValues([
            'first_name' => 'Rakib',
            'last_name' => 'Hossain',
        ]));

        if ($i % 1000 === 0) {
            flush();
        }
    }
});

$writer->toBrowser();
```

--------------------------------

### Defensive Excel Export with Validation in PHP

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/errors.md

Ensures the output directory exists and is writable before initializing the writer and processing data rows.

```php
function exportToExcel($outputPath, $data) {
    try {
        // Validate output directory
        $outputDir = dirname($outputPath);
        if (!is_dir($outputDir)) {
            mkdir($outputDir, 0755, true);
        }
        
        if (!is_writable($outputDir)) {
            throw new Exception("Output directory is not writable: $outputDir");
        }
        
        // Create writer
        $writer = SimpleExcelWriter::create($outputPath);
        
        // Validate and write data
        foreach ($data as $row) {
            $validatedRow = validateRowData($row);
            $writer->addRow($validatedRow);
        }
        
        $writer->close();
        
    } catch (Exception $e) {
        logError("Export failed: " . $e->getMessage());
        return false;
    }
    
    return true;
}
```

--------------------------------

### Access Color Constants

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/types.md

Color constants used for styling.

```php
OpenSpout\Common\Entity\Style\Color
```

--------------------------------

### Retrieve headers with getHeaders()

Source: https://github.com/spatie/simple-excel/blob/main/_autodocs/api-reference/SimpleExcelReader.md

Returns the header row as an array, or null if no header row is present.

```php
public function getHeaders(): ?array
```

```php
$reader = SimpleExcelReader::create('data.csv');
$headers = $reader->getHeaders();
// Returns: ['email', 'first_name', 'last_name']
```
Tokens:
Raw