wip

app/Enums/Accounting/BudgetSourceType.php

+<?php
+
+namespace App\Enums\Accounting;
+
+use App\Enums\Concerns\ParsesEnum;
+use Filament\Support\Contracts\HasLabel;
+
+enum BudgetSourceType: string implements HasLabel
+{
+    use ParsesEnum;
+
+    case Budget = 'budget';
+    case Actuals = 'actuals';
+
+    public function getLabel(): string
+    {
+        return match ($this) {
+            self::Budget => 'Copy from a previous budget',
+            self::Actuals => 'Use historical actuals',
+        };
+    }
+
+    public function isBudget(): bool
+    {
+        return $this === self::Budget;
+    }
+
+    public function isActuals(): bool
+    {
+        return $this === self::Actuals;
+    }
+}

app/Filament/Company/Resources/Accounting/BudgetResource.php

                                 Header::make('Account')
                                     ->label('Account')
                                     ->width('200px'),
+                                Header::make('total')
+                                    ->label('Total')
+                                    ->width('120px')
+                                    ->align(Alignment::Right),
+                                Header::make('action')
+                                    ->label('')
+                                    ->width('40px')
+                                    ->align(Alignment::Center),
                             ];
 
                             foreach ($periods as $period) {
                                     ->align(Alignment::Right);
                             }
 
-                            $headers[] = Header::make('total')
-                                ->label('Total')
-                                ->width('120px')
-                                ->align(Alignment::Right);
-
                             return [
                                 CustomTableRepeater::make('budgetItems')
                                     ->relationship()
                                             ->hiddenLabel()
                                             ->content(fn (BudgetItem $record) => $record->account->name ?? ''),
 
+                                        Forms\Components\TextInput::make('total')
+                                            ->hiddenLabel()
+                                            ->mask(RawJs::make('$money($input)'))
+                                            ->stripCharacters(',')
+                                            ->numeric()
+                                            ->afterStateHydrated(function ($component, $state, BudgetItem $record) use ($periods) {
+                                                $total = 0;
+                                                // Calculate the total for this budget item across all periods
+                                                foreach ($periods as $period) {
+                                                    $allocation = $record->allocations->firstWhere('period', $period);
+                                                    $total += $allocation ? $allocation->amount : 0;
+                                                }
+                                                $component->state($total);
+                                            })
+                                            ->dehydrated(false),
+
+                                        Forms\Components\Actions::make([
+                                            Forms\Components\Actions\Action::make('disperse')
+                                                ->label('Disperse')
+                                                ->icon('heroicon-m-chevron-double-right')
+                                                ->color('primary')
+                                                ->iconButton()
+                                                ->action(function (Forms\Set $set, Forms\Get $get, BudgetItem $record, $livewire) use ($periods) {
+                                                    $total = CurrencyConverter::convertToCents($get('total'));
+                                                    ray($total);
+                                                    $numPeriods = count($periods);
+
+                                                    if ($numPeriods === 0) {
+                                                        return;
+                                                    }
+
+                                                    $baseAmount = floor($total / $numPeriods);
+                                                    $remainder = $total - ($baseAmount * $numPeriods);
+
+                                                    foreach ($periods as $index => $period) {
+                                                        $amount = $baseAmount + ($index === 0 ? $remainder : 0);
+                                                        $formattedAmount = CurrencyConverter::convertCentsToFormatSimple($amount);
+                                                        $set("allocations.{$period}", $formattedAmount);
+                                                    }
+                                                }),
+                                        ]),
+
                                         // Create a field for each period
                                         ...collect($periods)->map(function ($period) {
                                             return Forms\Components\TextInput::make("allocations.{$period}")
                                                 })
                                                 ->dehydrated(false); // We'll handle saving manually
                                         })->toArray(),
-
-                                        Forms\Components\Placeholder::make('total')
-                                            ->hiddenLabel()
-                                            ->content(function (BudgetItem $record) use ($periods) {
-                                                $total = 0;
-
-                                                // Calculate the total for this budget item across all periods
-                                                foreach ($periods as $period) {
-                                                    $allocation = $record->allocations->firstWhere('period', $period);
-                                                    $total += $allocation ? $allocation->amount : 0;
-                                                }
-
-                                                return CurrencyConverter::formatToMoney($total);
-                                            }),
                                     ])
                                     ->spreadsheet()
                                     ->itemLabel(fn (BudgetItem $record) => $record->account->name ?? 'Budget Item')

app/Filament/Company/Resources/Accounting/BudgetResource/Pages/CreateBudget.php

 namespace App\Filament\Company\Resources\Accounting\BudgetResource\Pages;
 
 use App\Enums\Accounting\BudgetIntervalType;
+use App\Enums\Accounting\BudgetSourceType;
 use App\Facades\Accounting;
 use App\Filament\Company\Resources\Accounting\BudgetResource;
 use App\Filament\Forms\Components\CustomSection;
 use App\Models\Accounting\Account;
 use App\Models\Accounting\Budget;
-use App\Models\Accounting\BudgetAllocation;
 use App\Models\Accounting\BudgetItem;
 use App\Utilities\Currency\CurrencyConverter;
 use Filament\Forms;
 
     public function getAccountsWithActuals(): Collection
     {
-        $fiscalYear = $this->data['actuals_fiscal_year'] ?? null;
+        $fiscalYear = $this->data['source_fiscal_year'] ?? null;
 
         if (blank($fiscalYear)) {
             return collect();
 
     public function getAccountsWithoutActuals(): Collection
     {
-        $fiscalYear = $this->data['actuals_fiscal_year'] ?? null;
+        $fiscalYear = $this->data['source_fiscal_year'] ?? null;
 
         if (blank($fiscalYear)) {
             return collect();
 
     public function getAccountBalances(): Collection
     {
-        $fiscalYear = $this->data['actuals_fiscal_year'] ?? null;
+        $fiscalYear = $this->data['source_fiscal_year'] ?? null;
 
         if (blank($fiscalYear)) {
             return collect();
 
                     Forms\Components\Grid::make(1)
                         ->schema([
-                            Forms\Components\Select::make('prefill_method')
+                            Forms\Components\Select::make('source_type')
                                 ->label('Prefill Method')
-                                ->options([
-                                    'previous_budget' => 'Copy from a previous budget',
-                                    'actuals' => 'Use historical actuals',
-                                ])
+                                ->options(BudgetSourceType::class)
                                 ->live()
                                 ->required(),
 
                                     ->pluck('name', 'id'))
                                 ->searchable()
                                 ->required()
-                                ->visible(fn (Forms\Get $get) => $get('prefill_method') === 'previous_budget'),
+                                ->visible(fn (Forms\Get $get) => BudgetSourceType::parse($get('source_type'))?->isBudget()),
 
                             // If user selects to use historical actuals
-                            Forms\Components\Select::make('actuals_fiscal_year')
-                                ->label('Reference Fiscal Year')
+                            Forms\Components\Select::make('source_fiscal_year')
+                                ->label('Fiscal Year')
                                 ->options(function () {
                                     $options = [];
                                     $company = auth()->user()->currentCompany;
                                     // Update the selected_accounts field to exclude accounts without actuals
                                     $set('selected_accounts', $accountIdsWithoutActuals);
                                 })
-                                ->visible(fn (Forms\Get $get) => $get('prefill_method') === 'actuals'),
+                                ->visible(fn (Forms\Get $get) => BudgetSourceType::parse($get('source_type'))?->isActuals()),
                         ])->visible(fn (Forms\Get $get) => $get('prefill_data') === true),
 
                     CustomSection::make('Account Selection')
                                     return $this->getBudgetableAccounts()->pluck('name', 'id')->toArray();
                                 })
                                 ->descriptions(function (Forms\Components\CheckboxList $component) {
-                                    $fiscalYear = $this->data['actuals_fiscal_year'] ?? null;
+                                    $fiscalYear = $this->data['source_fiscal_year'] ?? null;
 
                                     if (blank($fiscalYear)) {
                                         return [];
                                     $set('exclude_accounts_without_actuals', $allAccountsWithoutActualsSelected);
                                 }),
                         ])
-                        ->visible(function () {
+                        ->visible(function (Forms\Get $get) {
                             // Only show when using actuals with valid fiscal year AND accounts without transactions exist
-                            $prefillMethod = $this->data['prefill_method'] ?? null;
+                            $prefillSourceType = BudgetSourceType::parse($get('source_type'));
 
-                            if ($prefillMethod !== 'actuals' || blank($this->data['actuals_fiscal_year'] ?? null)) {
+                            if ($prefillSourceType !== BudgetSourceType::Actuals || blank($get('source_fiscal_year'))) {
                                 return false;
                             }
 
     {
         /** @var Budget $budget */
         $budget = Budget::create([
+            'source_budget_id' => $data['source_budget_id'] ?? null,
+            'source_fiscal_year' => $data['source_fiscal_year'] ?? null,
+            'source_type' => $data['source_type'] ?? null,
             'name' => $data['name'],
             'interval_type' => $data['interval_type'],
             'start_date' => $data['start_date'],
             $budgetEndDate = Carbon::parse($data['end_date']);
 
             // Determine amounts based on the prefill method
-            $amounts = match ($data['prefill_method'] ?? null) {
-                'actuals' => $this->getAmountsFromActuals($account, $data['actuals_fiscal_year'], BudgetIntervalType::parse($data['interval_type'])),
+            $amounts = match ($data['source_type'] ?? null) {
+                'actuals' => $this->getAmountsFromActuals($account, $data['source_fiscal_year'], BudgetIntervalType::parse($data['interval_type'])),
                 'previous_budget' => $this->getAmountsFromPreviousBudget($account, $data['source_budget_id'], BudgetIntervalType::parse($data['interval_type'])),
                 default => $this->generateZeroAmounts($data['start_date'], $data['end_date'], BudgetIntervalType::parse($data['interval_type'])),
             };
             BudgetIntervalType::Month => $date->format('M Y'),
             BudgetIntervalType::Quarter => 'Q' . $date->quarter . ' ' . $date->year,
             BudgetIntervalType::Year => (string) $date->year,
-            default => $date->format('Y-m-d'),
         };
     }
 

app/Filament/Company/Resources/Accounting/BudgetResource/RelationManagers/BudgetItemsRelationManager.php

 
 namespace App\Filament\Company\Resources\Accounting\BudgetResource\RelationManagers;
 
+use App\Filament\Tables\Columns\DeferredTextInputColumn;
+use App\Models\Accounting\BudgetAllocation;
 use App\Models\Accounting\BudgetItem;
+use Filament\Notifications\Notification;
 use Filament\Resources\RelationManagers\RelationManager;
+use Filament\Tables\Actions\Action;
 use Filament\Tables\Columns\TextColumn;
-use Filament\Tables\Columns\TextInputColumn;
 use Filament\Tables\Table;
+use Livewire\Attributes\On;
 
 class BudgetItemsRelationManager extends RelationManager
 {
 
     protected static bool $isLazy = false;
 
+    // Store changes that are pending
+    public array $batchChanges = [];
+
+    // Listen for events from the custom column
+
+    #[On('batch-column-changed')]
+    public function handleBatchColumnChanged($data): void
+    {
+        ray($data);
+        // Store the changed value
+        $key = "{$data['recordKey']}.{$data['name']}";
+        $this->batchChanges[$key] = $data['value'];
+    }
+
+    #[On('save-batch-changes')]
+    public function saveBatchChanges(): void
+    {
+        ray('Saving batch changes');
+        foreach ($this->batchChanges as $key => $value) {
+            // Parse the composite key
+            [$recordKey, $column] = explode('.', $key, 2);
+
+            // Extract period from the column name (e.g., "allocations_by_period.2023-Q1")
+            preg_match('/allocations_by_period\.(.+)/', $column, $matches);
+            $period = $matches[1] ?? null;
+
+            if (! $period) {
+                continue;
+            }
+
+            // Find the record
+            $record = BudgetItem::find($recordKey);
+            if (! $record) {
+                continue;
+            }
+
+            // Update the allocation
+            $allocation = $record->allocations->firstWhere('period', $period);
+            if ($allocation) {
+                $allocation->update(['amount' => $value]);
+            } else {
+                $record->allocations()->create([
+                    'period' => $period,
+                    'amount' => $value,
+                    // Add other required fields
+                ]);
+            }
+        }
+
+        // Clear the batch changes
+        $this->batchChanges = [];
+
+        // Notify the user
+        Notification::make()
+            ->title('Budget allocations updated')
+            ->success()
+            ->send();
+    }
+
     public function table(Table $table): Table
     {
         $budget = $this->getOwnerRecord();
 
         // Get distinct periods for this budget
-        $periods = \App\Models\Accounting\BudgetAllocation::query()
+        $periods = BudgetAllocation::query()
             ->join('budget_items', 'budget_allocations.budget_item_id', '=', 'budget_items.id')
             ->where('budget_items.budget_id', $budget->id)
             ->orderBy('start_date')
             ->values()
             ->toArray();
 
+        ray($this->batchChanges);
+
         return $table
             ->recordTitleAttribute('account_id')
             ->paginated(false)
             ->modifyQueryUsing(
                 fn ($query) => $query->with(['account', 'allocations'])
             )
+            ->headerActions([
+                Action::make('saveBatchChanges')
+                    ->label('Save All Changes')
+                    ->action('saveBatchChanges')
+                    ->color('primary')
+                    ->icon('heroicon-o-check-circle'),
+            ])
             ->columns(array_merge([
                 TextColumn::make('account.name')
                     ->label('Accounts')
                     ->sortable()
                     ->searchable(),
             ], collect($periods)->map(
-                fn ($period) => TextInputColumn::make("allocations_by_period.{$period}")
+                fn ($period) => DeferredTextInputColumn::make("allocations_by_period.{$period}")
                     ->label($period)
-                    ->getStateUsing(
-                        fn ($record) => $record->allocations->firstWhere('period', $period)?->amount
-                    )
-                    ->updateStateUsing(function (BudgetItem $record, $state) use ($period) {
-                        $allocation = $record->allocations->firstWhere('period', $period);
-
-                        if ($allocation) {
-                            $allocation->update(['amount' => $state]);
+                    ->getStateUsing(function ($record, DeferredTextInputColumn $column) use ($period) {
+                        $key = "{$record->getKey()}.{$column->getName()}";
+
+                        // Check if batch change exists
+                        if (isset($this->batchChanges[$key])) {
+                            return $this->batchChanges[$key];
                         }
+
+                        return $record->allocations->firstWhere('period', $period)?->amount;
                     })
+                    ->batchMode(),
             )->all()));
     }
 }

app/Filament/Tables/Columns/DeferredTextInputColumn.php

+<?php
+
+namespace App\Filament\Tables\Columns;
+
+use Closure;
+use Filament\Tables\Columns\TextInputColumn;
+
+class DeferredTextInputColumn extends TextInputColumn
+{
+    protected string $view = 'filament.tables.columns.deferred-text-input-column';
+
+    protected bool | Closure $batchMode = false;
+
+    public function batchMode(bool | Closure $condition = true): static
+    {
+        $this->batchMode = $condition;
+
+        return $this;
+    }
+
+    public function getBatchMode(): bool
+    {
+        return $this->evaluate($this->batchMode);
+    }
+}

app/Models/Accounting/Budget.php

 use App\Concerns\Blamable;
 use App\Concerns\CompanyOwned;
 use App\Enums\Accounting\BudgetIntervalType;
+use App\Enums\Accounting\BudgetSourceType;
 use App\Enums\Accounting\BudgetStatus;
 use App\Filament\Company\Resources\Accounting\BudgetResource;
+use App\Models\User;
 use Filament\Actions\Action;
 use Filament\Actions\MountableAction;
 use Filament\Actions\ReplicateAction;
 use Illuminate\Database\Eloquent\Casts\Attribute;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\HasMany;
 use Illuminate\Database\Eloquent\Relations\HasManyThrough;
 use Illuminate\Support\Carbon;
 
     protected $fillable = [
         'company_id',
+        'source_budget_id',
+        'source_fiscal_year',
+        'source_type',
         'name',
         'start_date',
         'end_date',
         'interval_type', // day, week, month, quarter, year
         'notes',
         'approved_at',
+        'approved_by_id',
         'closed_at',
         'created_by',
         'updated_by',
     ];
 
     protected $casts = [
+        'source_fiscal_year' => 'integer',
+        'source_type' => BudgetSourceType::class,
         'start_date' => 'date',
         'end_date' => 'date',
         'status' => BudgetStatus::class,
         'closed_at' => 'datetime',
     ];
 
+    public function sourceBudget(): BelongsTo
+    {
+        return $this->belongsTo(self::class, 'source_budget_id');
+    }
+
+    public function derivedBudgets(): HasMany
+    {
+        return $this->hasMany(self::class, 'source_budget_id');
+    }
+
+    public function approvedBy(): BelongsTo
+    {
+        return $this->belongsTo(User::class, 'approved_by_id');
+    }
+
     public function budgetItems(): HasMany
     {
         return $this->hasMany(BudgetItem::class);
 
     /**
      * Get all periods for this budget in chronological order.
-     *
-     * @return array
      */
     public function getPeriods(): array
     {
             ->toArray();
     }
 
-
     public function isDraft(): bool
     {
         return $this->status === BudgetStatus::Draft;

database/migrations/2025_03_15_191245_create_budgets_table.php

         Schema::create('budgets', function (Blueprint $table) {
             $table->id();
             $table->foreignId('company_id')->constrained()->cascadeOnDelete();
+            $table->foreignId('source_budget_id')->nullable()->constrained('budgets')->nullOnDelete();
+            // Source fiscal year
+            $table->year('source_fiscal_year')->nullable();
+            $table->string('source_type')->nullable(); // budget, actuals
             $table->string('name');
             $table->date('start_date');
             $table->date('end_date');
             $table->string('interval_type')->default('month'); // day, week, month, quarter, year
             $table->text('notes')->nullable();
             $table->timestamp('approved_at')->nullable();
+            $table->foreignId('approved_by_id')->nullable()->constrained('users')->nullOnDelete();
             $table->timestamp('closed_at')->nullable();
             $table->foreignId('created_by')->nullable()->constrained('users')->nullOnDelete();
             $table->foreignId('updated_by')->nullable()->constrained('users')->nullOnDelete();

resources/css/filament/company/form-fields.css

     .table-repeater-container {
         border: 1px solid #e5e7eb !important;
         border-radius: 0 !important;
-        box-shadow: 0 1px 3px rgba(0, 0, 0, 0.05);
         @apply ring-0 !important;
     }
 
 
     .table-repeater-header {
         background-color: #f8f9fa !important;
-        border-radius: 0 !important;
     }
 
     .table-repeater-header-column {
         border: 1px solid #e5e7eb !important;
         background-color: #f8f9fa !important;
-        border-radius: 0 !important;
         font-weight: 600 !important;
         padding: 8px 12px !important;
     }
 
     .table-repeater-column input {
         text-align: right !important;
-        width: 100% !important;
     }
 
     /* Flatten inputs */
     .fi-input-wrapper,
     .fi-input {
         padding: 0 !important;
-        width: 100% !important;
     }
 
     .fi-input-wrp,
     .fi-fo-file-upload .filepond--root {
-        @apply ring-0 bg-transparent shadow-none !important;
+        @apply ring-0 bg-transparent shadow-none rounded-none !important;
     }
 
     .fi-input-wrp input {
-        @apply bg-transparent border-0 shadow-none !important;
+        @apply bg-transparent !important;
     }
 
     /* Focus states */
         z-index: 1 !important;
     }
 
-    .fi-input-wrp:focus-within {
-        @apply ring-0 shadow-none !important;
-    }
-
     input:focus,
     select:focus,
     textarea:focus {
     }
 }
 
+.is-spreadsheet .table-repeater-column .fi-input-wrp-suffix {
+    padding-right: 0 !important;
+}
+

resources/views/filament/tables/columns/deferred-text-input-column.blade.php

+@php
+    use Filament\Support\Enums\Alignment;
+
+    $isDisabled = $isDisabled();
+    $state = $getState();
+    $mask = $getMask();
+    $batchMode = $getBatchMode();
+
+    $alignment = $getAlignment() ?? Alignment::Start;
+
+    if (! $alignment instanceof Alignment) {
+        $alignment = filled($alignment) ? (Alignment::tryFrom($alignment) ?? $alignment) : null;
+    }
+
+    if (filled($mask)) {
+        $type = 'text';
+    } else {
+        $type = $getType();
+    }
+@endphp
+
+<div
+    x-data="{
+        error: undefined,
+
+        isEditing: false,
+
+        isLoading: false,
+
+        name: @js($getName()),
+
+        recordKey: @js($recordKey),
+
+        state: @js($state),
+    }"
+    x-init="
+        () => {
+            Livewire.hook('commit', ({ component, commit, succeed, fail, respond }) => {
+                succeed(({ snapshot, effect }) => {
+                    $nextTick(() => {
+                        if (component.id !== @js($this->getId())) {
+                            return
+                        }
+
+                        if (isEditing) {
+                            return
+                        }
+
+                        if (! $refs.newState) {
+                            return
+                        }
+
+                        let newState = $refs.newState.value.replaceAll('\\'+String.fromCharCode(34), String.fromCharCode(34))
+
+                        if (state === newState) {
+                            return
+                        }
+
+                        state = newState
+                    })
+                })
+            })
+        }
+    "
+    {{
+        $attributes
+            ->merge($getExtraAttributes(), escape: false)
+            ->class([
+                'fi-ta-text-input w-full min-w-48',
+                'px-3 py-4' => ! $isInline(),
+            ])
+    }}
+>
+    <input
+        type="hidden"
+        value="{{ str($state)->replace('"', '\\"') }}"
+        x-ref="newState"
+    />
+
+    <x-filament::input.wrapper
+        :alpine-disabled="'isLoading || ' . \Illuminate\Support\Js::from($isDisabled)"
+        alpine-valid="error === undefined"
+        x-tooltip="
+            error === undefined
+                ? false
+                : {
+                    content: error,
+                    theme: $store.theme,
+                }
+        "
+        x-on:click.stop.prevent=""
+    >
+        {{-- format-ignore-start --}}
+        <x-filament::input
+            :disabled="$isDisabled"
+            :input-mode="$getInputMode()"
+            :placeholder="$getPlaceholder()"
+            :step="$getStep()"
+            :type="$type"
+            :x-bind:disabled="$isDisabled ? null : 'isLoading'"
+            x-model="state"
+            x-on:blur="isEditing = false"
+            x-on:focus="isEditing = true"
+            :attributes="
+                \Filament\Support\prepare_inherited_attributes(
+                    $getExtraInputAttributeBag()
+                        ->merge([
+                            'x-on:change' . ($type === 'number' ? '.debounce.1s' : null) => $batchMode ? '
+                                $wire.dispatch(\'batch-column-changed\', {
+                                    data: {
+                                        name: name,
+                                        recordKey: recordKey,
+                                        value: $event.target.value
+                                    }
+                                })
+                            ' : '
+                                isLoading = true
+
+                                const response = await $wire.updateTableColumnState(
+                                    name,
+                                    recordKey,
+                                    $event.target.value,
+                                )
+
+                                error = response?.error ?? undefined
+
+                                if (! error) {
+                                    state = response
+                                }
+
+                                isLoading = false
+                            ',
+                            'x-on:keydown.enter' => $batchMode ? '$wire.dispatch(\'save-batch-changes\')' : '',
+                            'x-mask' . ($mask instanceof \Filament\Support\RawJs ? ':dynamic' : '') => filled($mask) ? $mask : null,
+                        ])
+                        ->class([
+                            match ($alignment) {
+                                Alignment::Start => 'text-start',
+                                Alignment::Center => 'text-center',
+                                Alignment::End => 'text-end',
+                                Alignment::Left => 'text-left',
+                                Alignment::Right => 'text-right',
+                                Alignment::Justify, Alignment::Between => 'text-justify',
+                                default => $alignment,
+                            },
+                        ])
+                )
+            "
+        />
+        {{-- format-ignore-end --}}
+    </x-filament::input.wrapper>
+</div>