Presets Service

import {
  DEFAULT_PRESETS,
  loadCustomPresets,
  saveCustomPresets,
  createCustomPreset,
  cloneConfig,
  getDefaultConfig
} from '$lib/services/presets';

interface PresetDefinition {
  id: string;
  name: string;
  config: ConversionConfig;
  builtIn?: boolean;
}

const DEFAULT_PRESETS: PresetDefinition[];

async function loadCustomPresets(): Promise<PresetDefinition[]>

const customPresets = await loadCustomPresets();
const allPresets = [...DEFAULT_PRESETS, ...customPresets];

async function saveCustomPresets(
  presets: PresetDefinition[]
): Promise<void>

const updated = [...customPresets, newPreset];
await saveCustomPresets(updated);

function createCustomPreset(
  name: string,
  config: ConversionConfig
): PresetDefinition

import { createCustomPreset } from '$lib/services/presets';
import type { ConversionConfig } from '$lib/types';

const config: ConversionConfig = {
  container: 'mp4',
  videoCodec: 'libx264',
  videoBitrateMode: 'crf',
  crf: 20,
  // ... rest of config
};

const preset = createCustomPreset('My Custom Preset', config);
// preset.id is a generated UUID
// preset.name is 'My Custom Preset'
// preset.config is a deep clone of the config

function cloneConfig(
  config: ConversionConfig
): ConversionConfig

const original = getDefaultConfig();
const copy = cloneConfig(original);

copy.crf = 18; // Doesn't affect original

function getDefaultConfig(): ConversionConfig

const config = getDefaultConfig();
// Returns a copy of the 'Balanced MP4' preset config

// From: src/lib/features/conversion/usePresets.svelte.ts

import {
  DEFAULT_PRESETS,
  loadCustomPresets,
  saveCustomPresets,
  createCustomPreset,
  cloneConfig
} from '$lib/services/presets';
import { normalizeConversionConfig } from '$lib/services/config';
import { FileStatus, type PresetDefinition } from '$lib/types';

export function createPresetsManager(callbacks) {
  let customPresets = $state<PresetDefinition[]>([]);
  
  // Combine built-in and custom presets
  const presets = $derived([
    ...DEFAULT_PRESETS, 
    ...customPresets
  ] as PresetDefinition[]);

  // Load custom presets on init
  async function loadPresets() {
    customPresets = await loadCustomPresets();
  }

  // Apply preset to selected file
  function applyPresetToSelection(preset: PresetDefinition) {
    const selectedFile = callbacks.getSelectedFile();
    if (!selectedFile) return;

    const nextConfig = normalizeConversionConfig(
      cloneConfig(preset.config),
      selectedFile.metadata
    );
    
    callbacks.onFilesUpdate((files) =>
      files.map((f) => 
        f.id === selectedFile.id 
          ? { ...f, config: nextConfig } 
          : f
      )
    );
  }

  // Apply preset to all idle files
  function handleApplyPresetToAll(preset: PresetDefinition) {
    callbacks.onFilesUpdate((files) =>
      files.map((f) =>
        f.status === FileStatus.IDLE
          ? {
              ...f,
              config: normalizeConversionConfig(
                cloneConfig(preset.config), 
                f.metadata
              )
            }
          : f
      )
    );
  }

  // Save current config as new preset
  async function handleSavePreset(name: string): Promise<boolean> {
    const selectedFile = callbacks.getSelectedFile();
    if (!selectedFile) return false;

    const trimmedName = name.trim();
    if (!trimmedName) return false;

    const newPreset = createCustomPreset(trimmedName, selectedFile.config);
    const updated = [...customPresets, newPreset];
    
    try {
      await saveCustomPresets(updated);
      customPresets = updated;
      return true;
    } catch (error) {
      console.error('Failed to save preset:', error);
      return false;
    }
  }

  // Delete custom preset
  async function handleDeletePreset(id: string): Promise<boolean> {
    const target = customPresets.find((p) => p.id === id);
    if (!target) return false;

    const updated = customPresets.filter((p) => p.id !== id);
    
    try {
      await saveCustomPresets(updated);
      customPresets = updated;
      return true;
    } catch (error) {
      console.error('Failed to delete preset:', error);
      return false;
    }
  }

  return {
    get presets() { return presets; },
    loadPresets,
    applyPresetToSelection,
    handleApplyPresetToAll,
    handleSavePreset,
    handleDeletePreset
  };
}

// Good
const config = cloneConfig(preset.config);
applyToFile(config);

// Bad - modifies the preset!
preset.config.crf = 18;
applyToFile(preset.config);

import { normalizeConversionConfig } from '$lib/services/config';

const config = normalizeConversionConfig(
  cloneConfig(preset.config),
  fileMetadata
);

const name = userInput.trim();
if (!name) {
  console.error('Preset name cannot be empty');
  return;
}

const preset = createCustomPreset(name, config);

try {
  await saveCustomPresets(updated);
  showSuccess('Preset saved');
} catch (error) {
  console.error('Failed to save preset:', error);
  showError('Failed to save preset');
  // Revert to previous state
}