TOON for Laravel

https://github.com/sbsaga/toon

TOON for Laravel is a token-efficient data format library that converts JSON and PHP arrays into...

Tokens:9,473

Snippets:51

Trust Score:5.7

License:MIT

Update:11 months ago

Show doc for...

Tokens:

Tokens:

### Install TOON for Laravel using Composer

Source: https://github.com/sbsaga/toon/wiki/Home

This command installs the TOON for Laravel library using Composer. It automatically discovers the service provider and facade, making it ready for use in your Laravel project.

```bash
composer require sbsaga/toon
```

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

### Use TOON Artisan Commands for Conversion

Source: https://github.com/sbsaga/toon/wiki/Home

These examples showcase the use of Artisan commands provided by the TOON for Laravel package. They allow for converting JSON files to TOON, decoding TOON files back to JSON with pretty printing, and specifying an output file for the conversion.

```bash
php artisan toon:convert storage/test.json
```

```bash
php artisan toon:convert storage/test.toon --decode --pretty
```

```bash
php artisan toon:convert storage/test.json --output=storage/result.toon
```

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

### GET /toon-benchmark

Source: https://github.com/sbsaga/toon/blob/main/README.md

This endpoint provides a quick benchmark comparing the size of original JSON data with the size of data compressed using the TOON format. It returns the sizes in bytes, the saving percentage, and the content in both formats.

```APIDOC
## GET /toon-benchmark

### Description
This endpoint provides a quick benchmark comparing the size of original JSON data with the size of data compressed using the TOON format. It returns the sizes in bytes, the saving percentage, and the content in both formats.

### Method
GET

### Endpoint
/toon-benchmark

### Parameters
No path or query parameters.

### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **json_size_bytes** (integer) - The size of the original JSON data in bytes.
- **toon_size_bytes** (integer) - The size of the TOON compressed data in bytes.
- **saving_percent** (float) - The percentage of space saved by using TOON format.
- **json_content** (string) - The original JSON content.
- **toon_content** (string) - The TOON compressed content.

#### Response Example
```json
{
  "json_size_bytes": 7718,
  "toon_size_bytes": 2538,
  "saving_percent": 67.12,
  "json_content": "{\"key\": \"value\"}",
  "toon_content": "[compressed_toon_data]"
}
```
```

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

### Direct Toon Conversion with Custom Configuration (PHP)

Source: https://context7.com/sbsaga/toon/llms.txt

This example demonstrates direct usage of the ToonConverter class for fine-grained control over conversion settings. It allows customization of parameters like minimum rows for tabular format, preview limits, and escaping styles. The input is a PHP array, and the output is a TOON formatted string.

```php
use Sbsaga\Toon\Converters\ToonConverter;

// Create converter with custom settings
$converter = new ToonConverter([
    'min_rows_to_tabular' => 3,      // Require at least 3 rows for table format
    'max_preview_items' => 50,        // Limit preview to 50 items
    'escape_style' => 'backslash'     // Use backslash escaping
]);

$data = [
    ['product' => 'Laptop', 'price' => 999.99, 'stock' => 15],
    ['product' => 'Mouse', 'price' => 29.99, 'stock' => 150],
    ['product' => 'Keyboard', 'price' => 79.99, 'stock' => 45],
    ['product' => 'Monitor', 'price' => 299.99, 'stock' => 8]
];

$toon = $converter->toToon($data);
echo $toon;

/* Output:
items[4]{product,price,stock}:
  Laptop,999.99,15
  Mouse,29.99,150
  Keyboard,79.99,45
  Monitor,299.99,8
*/

// Handle special characters with escaping
$message = ['note' => 'Hello, world: test\nNew line'];
$escaped = $converter->toToon($message);
// Output: note: Hello\, world\: test\nNew line
```

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

### Direct TOON to PHP Decoding with Custom Options (PHP)

Source: https://context7.com/sbsaga/toon/llms.txt

This example shows direct usage of the ToonDecoder class to convert TOON formatted strings back into PHP arrays. It supports custom options such as coercing scalar types and specifying escape styles. Error handling for parsing is included via a try-catch block for ToonException.

```php
use Sbsaga\Toon\Converters\ToonDecoder;

$decoder = new ToonDecoder([
    'coerce_scalar_types' => true,    // Convert "true" → bool, "123" → int
    'escape_style' => 'backslash'
]);

$toonInput = <<<TOON
config:
  enabled: true
  max_connections: 100
  timeout: 30.5
  database: null
features:
  items[3]{name,enabled}:
    caching,true
    logging,false
    monitoring,true
TOON;

try {
    $decoded = $decoder->fromToon($toonInput);
    print_r($decoded);
} catch (\Sbsaga\Toon\Exceptions\ToonException $e) {
    echo "Parse error: " . $e->getMessage();
}

/* Output:
Array
(
    [config] => Array
        (
            [enabled] => 1
            [max_connections] => 100
            [timeout] => 30.5
            [database] =>
        )
    [features] => Array
        (
            [0] => Array
                (
                    [name] => caching
                    [enabled] => 1
                )
            [1] => Array
                (
                    [name] => logging
                    [enabled] =>
                )
            [2] => Array
                (
                    [name] => monitoring
                    [enabled] => 1
                )
        )
)
*/
```

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

### Convert JSON to TOON format in PHP

Source: https://github.com/sbsaga/toon/wiki/Home

This PHP code snippet demonstrates how to convert a JSON data structure into the TOON format using the Toon facade. It takes a PHP array as input and outputs a compact, human-readable TOON string. The output shows an example of escaped characters and tabular representation for arrays.

```php
use Sbsaga\Toon\Facades\Toon;

$data = [
    'user' => 'Sagar',
    'message' => 'Hello, how are you?',
    'tasks' => [
        ['id' => 1, 'done' => false],
        ['id' => 2, 'done' => true],
    ],
];

$converted = Toon::convert($data);
echo $converted;
```

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

### Publish TOON Configuration File

Source: https://github.com/sbsaga/toon/wiki/Home

This Artisan command publishes the configuration file for TOON, allowing you to customize its behavior. The configuration options include enabling/disabling the library, escape style, minimum rows for tabular conversion, and maximum preview items.

```bash
php artisan vendor:publish --provider="Sbsaga\Toon\ToonServiceProvider" --tag=config
```

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

### Laravel Controller Integration

Source: https://context7.com/sbsaga/toon/llms.txt

Demonstrates how to integrate TOON into Laravel controllers to optimize AI prompt payloads before sending them to LLM APIs, saving on token costs.

```APIDOC
## Laravel Controller Integration

### Description
Use TOON within Laravel controllers to optimize AI prompt payloads before sending them to LLM APIs. This function helps reduce token usage and associated costs by converting large datasets into the compact TOON format.

### Method
(Controller method example)

### Parameters
(Based on typical HTTP request parameters for a controller)

### Request Example
```php
namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Sbsaga\Toon\Facades\Toon;

class AiPromptController extends Controller
{
    public function optimizePrompt(Request $request)
    {
        // Fetch large dataset from database
        $users = \App\Models\User::with('orders')
            ->limit(100)
            ->get()
            ->toArray();

        // Convert to TOON for token-efficient AI context
        $toonContext = Toon::convert($users);
        $stats = Toon::estimateTokens($toonContext);

        // Send to OpenAI with optimized context
        $prompt = "Analyze these users:\n\n{$toonContext}";

        // Your OpenAI API call here
        // $response = OpenAI::chat()->create([...]);

        return response()->json([
            'toon_size' => strlen($toonContext),
            'json_size' => strlen(json_encode($users)),
            'token_estimate' => $stats['tokens_estimate'],
            'compression_ratio' => round((strlen($toonContext) / strlen(json_encode($users))) * 100, 2) . '%',
            'optimized_prompt' => $toonContext
        ]);
    }
}
```

### Response
#### Success Response (200 JSON)
- **toon_size** (int) - The size in bytes of the TOON formatted string.
- **json_size** (int) - The size in bytes of the equivalent JSON formatted string.
- **token_estimate** (int) - The estimated number of tokens for the TOON formatted string.
- **compression_ratio** (string) - The percentage of size reduction achieved by TOON compared to JSON.
- **optimized_prompt** (string) - The TOON formatted string, ready to be used in AI prompts.

#### Response Example
```json
{
  "toon_size": 1500,
  "json_size": 4000,
  "token_estimate": 500,
  "compression_ratio": "37.5%",
  "optimized_prompt": "user[100]{\n  id,name,email\n}:\n  1,John Doe,john@example.com\n  2,Jane Smith,jane@example.com\n..."
}
```
```

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

### TOON Package Configuration (`config/toon.php`)

Source: https://context7.com/sbsaga/toon/llms.txt

Defines the configuration settings for the TOON package. Key parameters include enabling/disabling the package, character escaping methods, minimum rows for tabular rendering, maximum items for previews, and type coercion during decoding.

```php
// config/toon.php
return [
    // Enable/disable TOON package globally
    'enabled' => env('TOON_ENABLED', true),

    // Character escaping method
    'escape_style' => env('TOON_ESCAPE_STYLE', 'backslash'),

    // Minimum rows needed for tabular rendering
    'min_rows_to_tabular' => env('TOON_MIN_ROWS_TO_TABULAR', 2),

    // Maximum items shown in previews
    'max_preview_items' => env('TOON_MAX_PREVIEW_ITEMS', 200),

    // Type coercion during decoding
    'coerce_scalar_types' => env('TOON_COERCE_SCALARS', true),
];

```

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

### Artisan Commands

Source: https://github.com/sbsaga/toon/blob/main/README.md

The Sbsaga Toon package provides several Artisan commands for converting data between JSON and TOON formats, with options for decoding and specifying output files.

```APIDOC
## Artisan Commands

### Description
The Sbsaga Toon package provides several Artisan commands for converting data between JSON and TOON formats, with options for decoding and specifying output files.

### Commands

1.  **Convert JSON to TOON:**
    ```bash
    php artisan toon:convert storage/test.json
    ```
    Converts a JSON file to TOON format.

2.  **Convert TOON to JSON (decode and pretty print):**
    ```bash
    php artisan toon:convert storage/test.toon --decode --pretty
    ```
    Decodes a TOON file and outputs it as pretty-printed JSON.

3.  **Convert JSON to TOON with specified output:**
    ```bash
    php artisan toon:convert storage/test.json --output=storage/result.toon
    ```
    Converts a JSON file to TOON format and saves it to a specified output file.
```

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

### Environment File Configuration for TOON

Source: https://context7.com/sbsaga/toon/llms.txt

Sets environment variables to configure the TOON package behavior. These variables correspond to the keys defined in the `config/toon.php` file, allowing for easy customization of the package's operation without modifying code.

```dotenv
TOON_ENABLED=true
TOON_ESCAPE_STYLE=backslash
TOON_MIN_ROWS_TO_TABULAR=3
TOON_MAX_PREVIEW_ITEMS=100
TOON_COERCE_SCALARS=true

```

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

### Roundtrip Data Conversion Testing with TOON

Source: https://context7.com/sbsaga/toon/llms.txt

Demonstrates how to use `ToonConverter` and `ToonDecoder` to convert data to and from the TOON format, verifying data integrity through a roundtrip process. Includes testing for special character handling.

```php
use Sbsaga\Toon\Converters\ToonConverter;
use Sbsaga\Toon\Converters\ToonDecoder;

// Original data structure
$original = [
    'users' => [
        ['id' => 1, 'name' => 'Alice', 'active' => true],
        ['id' => 2, 'name' => 'Bob', 'active' => false]
    ],
    'config' => [
        'timeout' => 30,
        'retry' => true
    ]
];

// Convert to TOON
$converter = new ToonConverter();
$toon = $converter->toToon($original);

// Decode back to array
$decoder = new ToonDecoder();
$decoded = $decoder->fromToon($toon);

// Validate roundtrip accuracy
if ($original === $decoded) {
    echo "✓ Roundtrip conversion successful\n";
} else {
    echo "✗ Data mismatch detected\n";
    print_r(['original' => $original, 'decoded' => $decoded]);
}

// Test with special characters
$specialChars = ['message' => "Line 1: test, value\nLine 2: more\\data"];
$toonSpecial = $converter->toToon($specialChars);
$decodedSpecial = $decoder->fromToon($toonSpecial);

assert($specialChars['message'] === $decodedSpecial['message'], 'Special char handling failed');

```

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

### Integrate TOON for AI Prompt Optimization in Laravel Controller

Source: https://context7.com/sbsaga/toon/llms.txt

Demonstrates how to use the TOON package within a Laravel controller to optimize data payloads for AI prompts. It fetches data, converts it to TOON format for token efficiency, estimates token usage, and prepares an optimized prompt for an LLM API. Requires the TOON package, Laravel, and potentially an AI SDK.

```php
namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Sbsaga\Toon\Facades\Toon;

class AiPromptController extends Controller
{
    public function optimizePrompt(Request $request)
    {
        // Fetch large dataset from database
        $users = \App\Models\User::with('orders')
            ->limit(100)
            ->get()
            ->toArray();

        // Convert to TOON for token-efficient AI context
        $toonContext = Toon::convert($users);
        $stats = Toon::estimateTokens($toonContext);

        // Send to OpenAI with optimized context
        $prompt = "Analyze these users:\n\n{$toonContext}";

        // Your OpenAI API call here
        // $response = OpenAI::chat()->create([...]);

        return response()->json([
            'toon_size' => strlen($toonContext),
            'json_size' => strlen(json_encode($users)),
            'token_estimate' => $stats['tokens_estimate'],
            'compression_ratio' => round((strlen($toonContext) / strlen(json_encode($users))) * 100, 2) . '%',
            'optimized_prompt' => $toonContext
        ]);
    }
}
```

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

### Convert Files Between JSON and TOON using Artisan CLI (Bash)

Source: https://context7.com/sbsaga/toon/llms.txt

This section outlines Artisan commands for converting files between JSON and TOON formats. It covers encoding, decoding, specifying output files, piping input via STDIN, and using custom configuration files for batch processing and automation.

```bash
# Convert JSON file to TOON format
php artisan toon:convert storage/app/data.json --encode

# Convert TOON file back to JSON with pretty printing
php artisan toon:convert storage/app/data.toon --decode --pretty

# Save output to specific file
php artisan toon:convert storage/app/input.json --encode --output=storage/app/output.toon

# Read from STDIN (pipe input)
cat data.json | php artisan toon:convert --encode

# Use custom configuration file
php artisan toon:convert data.json --encode --config=config/custom-toon.php

# Decode with pretty JSON output to file
php artisan toon:convert data.toon --decode --pretty --output=result.json
```

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

### Benchmark JSON vs TOON Compression Performance (PHP)

Source: https://context7.com/sbsaga/toon/llms.txt

This route compares the performance of JSON encoding versus TOON compression. It generates sample data, encodes it using both methods, estimates token usage, and returns a JSON response detailing size and token reductions. Dependencies include Illuminate Support Facades and Sbsaga Toon Facades.

```php
use Illuminate\Support\Facades\Route;
use Sbsaga\Toon\Facades\Toon;

Route::get('/toon-benchmark', function () {
    // Load test data
    $testData = [
        'users' => [],
        'timestamp' => now()->toISOString(),
        'metadata' => ['version' => '1.0', 'source' => 'api']
    ];

    // Generate sample users
    for ($i = 1; $i <= 50; $i++) {
        $testData['users'][] = [
            'id' => $i,
            'name' => "User {$i}",
            'email' => "user{$i}@example.com",
            'active' => $i % 2 === 0,
            'balance' => round($i * 123.45, 2)
        ];
    }

    $jsonEncoded = json_encode($testData, JSON_PRETTY_PRINT);
    $toonEncoded = Toon::convert($testData);

    $jsonStats = Toon::estimateTokens($jsonEncoded);
    $toonStats = Toon::estimateTokens($toonEncoded);

    return response()->json([
        'json_size_bytes' => strlen($jsonEncoded),
        'toon_size_bytes' => strlen($toonEncoded),
        'json_tokens' => $jsonStats['tokens_estimate'],
        'toon_tokens' => $toonStats['tokens_estimate'],
        'size_reduction_percent' => round(100 - (strlen($toonEncoded) / strlen($jsonEncoded) * 100), 2),
        'token_reduction_percent' => round(100 - ($toonStats['tokens_estimate'] / $jsonStats['tokens_estimate'] * 100), 2),
        'json_preview' => substr($jsonEncoded, 0, 200) . '...',
        'toon_preview' => substr($toonEncoded, 0, 200) . '...'
    ]);
});
```

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

### Benchmark JSON vs TOON size in a Laravel Route

Source: https://github.com/sbsaga/toon/wiki/Home

This Laravel route demonstrates a real-world benchmark comparing the size of JSON and TOON formats. It reads a JSON file, converts it to TOON, and returns the sizes in bytes, along with the calculated saving percentage. This helps in visualizing the compression efficiency.

```php
use Illuminate\Support\Facades\Route;
use Sbsaga\Toon\Facades\Toon;

Route::get('/toon-benchmark', function () {
    $json = json_decode(file_get_contents(storage_path('app/users.json')), true);
    $jsonEncoded = json_encode($json, JSON_PRETTY_PRINT);
    $toonEncoded = Toon::convert($json);

    return response()->json([
        'json_size_bytes' => strlen($jsonEncoded),
        'toon_size_bytes' => strlen($toonEncoded),
        'saving_percent' => round(100 - (strlen($toonEncoded) / strlen($jsonEncoded) * 100), 2),
        'json_content' => $jsonEncoded,
        'toon_content' => $toonEncoded,
    ]);
});
```

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

### Estimate Tokens for a given string in PHP

Source: https://github.com/sbsaga/toon/wiki/Home

This PHP code snippet shows how to estimate the token count for a given string, likely in the TOON format, using the Toon facade. It returns an array containing the estimated number of words, characters, and tokens.

```php
$stats = Toon::estimateTokens($converted);
print_r($stats);
```

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

### Estimate Token Usage

Source: https://context7.com/sbsaga/toon/llms.txt

Calculates the approximate token consumption of a TOON-formatted string, allowing comparison with standard JSON token usage.

```APIDOC
## Estimate Token Usage

### Description
Calculate approximate token consumption for TOON-formatted strings to measure compression effectiveness. This is useful for understanding cost and performance benefits when interacting with LLMs.

### Method
`Toon::estimateTokens(string $formattedString): array`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **formattedString** (string) - Required - The string (either TOON or JSON) for which to estimate token usage.

### Request Example
```php
use Sbsaga\Toon\Facades\Toon;

$data = [
    'question' => 'Explain machine learning',
    'context' => 'User is a beginner',
    'model' => 'gpt-4',
    'temperature' => 0.7
];

$toon = Toon::convert($data);
$stats = Toon::estimateTokens($toon);

print_r($stats);

// Compare with original JSON
$json = json_encode($data);
$jsonStats = Toon::estimateTokens($json);
$savings = round(100 - ($stats['tokens_estimate'] / $jsonStats['tokens_estimate'] * 100), 2);
echo "Token savings: {$savings}%\n";
```

### Response
#### Success Response (array)
- **words** (int) - Approximate number of words.
- **chars** (int) - Approximate number of characters.
- **tokens_estimate** (int) - Estimated number of tokens.

#### Response Example
```
Array
(
    [words] => 8
    [chars] => 89
    [tokens_estimate] => 8
)
Token savings: 60.0%
```
```

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

### Estimate Tokens for TOON Data in Laravel

Source: https://github.com/sbsaga/toon/blob/main/README.md

Estimates the number of words, characters, and tokens for a given TOON string using the Toon facade. This helps in understanding the token efficiency of the format for AI models.

```php
$converted = "user: Sagar\nmessage: Hello\, how are you?\ntasks:\n  items[2]{done,id}:\n    false,1\n    true,2";

$stats = Toon::estimateTokens($converted);
print_r($stats);

```

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

### Estimate Token Usage of TOON String with Laravel Facade

Source: https://context7.com/sbsaga/toon/llms.txt

Calculates the approximate token count for a given TOON-formatted string, allowing developers to measure compression effectiveness against standard JSON. It returns an array containing word count, character count, and token estimate. Requires the TOON package and Laravel's Facade system.

```php
use Sbsaga\Toon\Facades\Toon;

$data = [
    'question' => 'Explain machine learning',
    'context' => 'User is a beginner',
    'model' => 'gpt-4',
    'temperature' => 0.7
];

$toon = Toon::convert($data);
$stats = Toon::estimateTokens($toon);

print_r($stats);

/* Output:
Array
(
    [words] => 8
    [chars] => 89
    [tokens_estimate] => 8
)
*/

// Compare with original JSON
$json = json_encode($data);
$jsonStats = Toon::estimateTokens($json);
$savings = round(100 - ($stats['tokens_estimate'] / $jsonStats['tokens_estimate'] * 100), 2);
echo "Token savings: {$savings}%\n";
```

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

### Convert Data to TOON Format

Source: https://context7.com/sbsaga/toon/llms.txt

Transforms JSON strings, PHP arrays, or objects into the compact TOON notation. This method is aliased as `encode()` for semantic clarity.

```APIDOC
## Convert Data to TOON Format

### Description
Transform JSON strings, arrays, or objects into compact TOON notation using the main conversion method. This method is also available as `encode()`.

### Method
`Toon::convert(array|object|string $data): string`
`Toon::encode(array|object|string $data): string`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **data** (array|object|string) - Required - The data to convert to TOON format.

### Request Example
```php
use Sbsaga\Toon\Facades\Toon;

$data = [
    'user' => 'Sagar',
    'message' => 'Hello, how are you?',
    'priority' => 'high',
    'tasks' => [
        ['id' => 1, 'title' => 'Review PR', 'done' => false],
        ['id' => 2, 'title' => 'Deploy app', 'done' => true],
        ['id' => 3, 'title' => 'Update docs', 'done' => false],
    ],
    'metadata' => [
        'created_at' => '2025-01-15',
        'version' => 2.1
    ]
];

$toon = Toon::convert($data);
echo $toon;
```

### Response
#### Success Response (string)
- **toon_string** (string) - The data converted into TOON format.

#### Response Example
```
user: Sagar
message: Hello\, how are you?
priority: high
tasks:
  items[3]{id,title,done}:
    1,Review PR,false
    2,Deploy app,true
    3,Update docs,false
metadata:
  created_at: 2025-01-15
  version: 2.1
```
```

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

### Convert PHP Array to TOON Format using Laravel Facade

Source: https://context7.com/sbsaga/toon/llms.txt

Transforms a nested PHP array with mixed data types into the compact TOON format using the Toon facade. The output is a string optimized for token efficiency in AI prompts. Requires the TOON package and Laravel's Facade system.

```php
use Sbsaga\Toon\Facades\Toon;

// Convert nested array with mixed data types
$data = [
    'user' => 'Sagar',
    'message' => 'Hello, how are you?',
    'priority' => 'high',
    'tasks' => [
        ['id' => 1, 'title' => 'Review PR', 'done' => false],
        ['id' => 2, 'title' => 'Deploy app', 'done' => true],
        ['id' => 3, 'title' => 'Update docs', 'done' => false],
    ],
    'metadata' => [
        'created_at' => '2025-01-15',
        'version' => 2.1
    ]
];

$toon = Toon::convert($data);
echo $toon;

/* Output:
user: Sagar
message: Hello\, how are you?
priority: high
tasks:
  items[3]{id,title,done}:
    1,Review PR,false
    2,Deploy app,true
    3,Update docs,false
metadata:
  created_at: 2025-01-15
  version: 2.1
*/

// Alternative: use encode() alias for semantic clarity
$toonEncoded = Toon::encode($data);
```

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

### Decode TOON Back to PHP Arrays

Source: https://context7.com/sbsaga/toon/llms.txt

Converts TOON format strings back into native PHP arrays. The decoding process includes automatic type coercion for values.

```APIDOC
## Decode TOON Back to PHP Arrays

### Description
Convert TOON format strings back to native PHP arrays with automatic type coercion. This is the reverse operation of `convert()`.

### Method
`Toon::decode(string $toonString): array`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **toonString** (string) - Required - The TOON formatted string to decode.

### Request Example
```php
use Sbsaga\Toon\Facades\Toon;

$toonString = <<<TOON
user: Alice
active: true
settings:
  theme: dark
  notifications: false
projects:
  items[2]{id,name,budget}:
    101,Website Redesign,50000
    102,Mobile App,75000.5
TOON;

$decoded = Toon::decode($toonString);
print_r($decoded);
```

### Response
#### Success Response (array)
- **decoded_array** (array) - The data decoded into a PHP array.

#### Response Example
```
Array
(
    [user] => Alice
    [active] => 1
    [settings] => Array
        (
            [theme] => dark
            [notifications] => 
        )
    [projects] => Array
        (
            [0] => Array
                (
                    [id] => 101
                    [name] => Website Redesign
                    [budget] => 50000
                )
            [1] => Array
                (
                    [id] => 102
                    [name] => Mobile App
                    [budget] => 75000.5
                )
        )
)
```
```

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

### Convert TOON format to JSON in PHP

Source: https://github.com/sbsaga/toon/wiki/Home

This PHP code snippet illustrates how to decode a TOON formatted string back into a JSON (PHP array) structure using the Toon facade. It takes a TOON string as input and outputs a PHP array which can then be processed or printed.

```php
$toon = <<<TOON
user: Sagar
tasks:
  items[2]{id,done}:
    1,false
    2,true
TOON;

$json = Toon::decode($toon);
print_r($json);
```

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

### Decode TOON String to PHP Array using Laravel Facade

Source: https://context7.com/sbsaga/toon/llms.txt

Converts a TOON-formatted string back into a native PHP array. The decoding process includes automatic type coercion, ensuring data integrity. This function is essential for processing data received in TOON format. Requires the TOON package and Laravel's Facade system.

```php
use Sbsaga\Toon\Facades\Toon;

$toonString = <<<TOON
user: Alice
active: true
settings:
  theme: dark
  notifications: false
projects:
  items[2]{id,name,budget}:
    101,Website Redesign,50000
    102,Mobile App,75000.5
TOON;

$decoded = Toon::decode($toonString);
print_r($decoded);

/* Output:
Array
(
    [user] => Alice
    [active] => 1
    [settings] => Array
        (
            [theme] => dark
            [notifications] =>
        )
    [projects] => Array
        (
            [0] => Array
                (
                    [id] => 101
                    [name] => Website Redesign
                    [budget] => 50000
                )
            [1] => Array
                (
                    [id] => 102
                    [name] => Mobile App
                    [budget] => 75000.5
                )
        )
)
*/
```

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

### Convert JSON to TOON in Laravel

Source: https://github.com/sbsaga/toon/blob/main/README.md

Converts a PHP array (representing JSON data) into the TOON format using the Toon facade. The output is a string in a compact, readable, and token-efficient format.

```php
use Sbsaga\Toon\Facades\Toon;

$data = [
    'user' => 'Sagar',
    'message' => 'Hello, how are you?',
    'tasks' => [
        ['id' => 1, 'done' => false],
        ['id' => 2, 'done' => true],
    ],
];

$converted = Toon::convert($data);
echo $converted;

```

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

### Convert TOON to JSON in Laravel

Source: https://github.com/sbsaga/toon/blob/main/README.md

Decodes a TOON formatted string back into a PHP array (representing JSON data) using the Toon facade. This allows for reversibility of the TOON data format.

```php
$toon = <<<TOON
user: Sagar
tasks:
  items[2]{id,done}:
    1,false
    2,true
TOON;

$json = Toon::decode($toon);
print_r($json);

```