Presets

interface PresetDefinition {
  id: string;                    // Unique identifier (UUID for custom presets)
  name: string;                  // Display name
  config: ConversionConfig;      // Complete conversion settings
  builtIn?: boolean;             // True for built-in presets (read-only)
}

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

export function getDefaultConfig(): ConversionConfig {
  return cloneConfig(DEFAULT_PRESETS[0].config);
}

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

const preset = createCustomPreset('My Custom Preset', currentConfig);
// Returns:
// {
//   id: 'uuid-v4',
//   name: 'My Custom Preset',
//   config: { ...currentConfig }
// }

export function createCustomPreset(name: string, config: ConversionConfig): PresetDefinition {
  return {
    id: uuidv4(),
    name: name.trim() || 'Untitled Preset',
    config: cloneConfig(config)
  };
}

import { saveCustomPresets } from '$lib/services/presets';

await saveCustomPresets([preset1, preset2, preset3]);

export async function saveCustomPresets(presets: PresetDefinition[]): Promise<void> {
  const store = await getStore();
  await store.set(PRESETS_KEY, presets);
  await store.save();
}

import { loadCustomPresets } from '$lib/services/presets';

const customPresets = await loadCustomPresets();
// Returns: PresetDefinition[]

export async function loadCustomPresets(): Promise<PresetDefinition[]> {
  try {
    const store = await getStore();
    const presets = await store.get<PresetDefinition[]>(PRESETS_KEY);
    return presets ?? [];
  } catch (error) {
    console.error('Failed to load presets from store', error);
    return [];
  }
}

const STORE_PATH = 'presets.dat';
const PRESETS_KEY = 'presets';

let storePromise: Promise<Store> | null = null;

async function getStore(): Promise<Store> {
  if (!storePromise) {
    storePromise = Store.load(STORE_PATH, {
      defaults: {
        [PRESETS_KEY]: []
      }
    });
  }
  return storePromise;
}

export function cloneConfig(config: ConversionConfig): ConversionConfig {
  return JSON.parse(JSON.stringify(config));
}

import { usePresets } from '$lib/features/conversion/usePresets.svelte';

const presets = usePresets();

// Access all presets (built-in + custom)
const allPresets = presets.all; // PresetDefinition[]

// Access only custom presets
const customPresets = presets.custom; // PresetDefinition[]

// Apply a preset to current configuration
presets.apply(presetId);

// Save current config as preset
presets.saveAs('My Preset Name');

// Delete a custom preset
presets.delete(presetId);

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

// Start with default config
const config = getDefaultConfig();

// Customize settings
config.container = 'mp4';
config.videoCodec = 'libx265';
config.videoBitrateMode = 'crf';
config.crf = 20;
config.resolution = '1080p';
config.audioCodec = 'aac';
config.audioBitrate = '192';
config.audioNormalize = true;

// Create preset
const preset = createCustomPreset('My H.265 Profile', config);

// Load existing custom presets
const existing = await loadCustomPresets();

// Add new preset and save
await saveCustomPresets([...existing, preset]);