feat: add asset import services

src/lib/services/effect-import.ts

@@ -0,0 +1,138 @@
+import { existsSync, promises as fs } from 'node:fs'
+import path from 'node:path'
+import { listOfficialEffects, resolveEffectSwfUrl } from '@/lib/services/effect-source'
+import { listLocalEffects, mergeEffect, removeEffect } from '@/lib/services/effectmap'
+import { downloadFile } from '@/lib/services/import/core/download'
+import { convertSwfToNitro } from '@/lib/services/swf-to-nitro'
+import type { EffectListItem, EffectMapEntry, ImportEffectResult } from '@/types/effects'
+
+export const EFFECT_NITRO_DIR = path.join(
+  /*turbopackIgnore: true*/ process.cwd(),
+  'public/nitro-assets/bundled/effect',
+)
+export const EFFECT_SWF_DIR = path.join(
+  /*turbopackIgnore: true*/ process.cwd(),
+  'public/swf/gordon',
+)
+
+export async function ensureEffectDirs(): Promise<void> {
+  await Promise.all(
+    [EFFECT_NITRO_DIR, EFFECT_SWF_DIR]
+      .filter((dir) => !existsSync(/*turbopackIgnore: true*/ dir))
+      .map((dir) => fs.mkdir(/*turbopackIgnore: true*/ dir, { recursive: true })),
+  )
+}
+
+function nitroPathFor(lib: string): string {
+  return path.join(/*turbopackIgnore: true*/ EFFECT_NITRO_DIR, `${lib}.nitro`)
+}
+
+export async function importSingleEffect(params: {
+  id: string
+  lib: string
+  type: string
+  revision: number
+  onProgress?: (status: string) => void
+}): Promise<ImportEffectResult> {
+  const { id, lib, type, revision, onProgress } = params
+  const warnings: string[] = []
+  await ensureEffectDirs()
+
+  const nitroPath = nitroPathFor(lib)
+
+  // Download SWF
+  onProgress?.('downloading')
+  const swfPath = path.join(/*turbopackIgnore: true*/ EFFECT_SWF_DIR, `${lib}.swf`)
+  let swfUrl: string
+  try {
+    swfUrl = await resolveEffectSwfUrl(lib)
+  } catch (err) {
+    return {
+      ok: false,
+      lib,
+      warnings,
+      error: `Could not resolve SWF URL: ${(err as Error).message}`,
+    }
+  }
+  const dl = await downloadFile(swfUrl, swfPath, { validate: 'swf' })
+  if (!dl.ok) return { ok: false, lib, warnings, error: `SWF download failed: ${swfUrl}` }
+
+  // Convert SWF → Nitro
+  onProgress?.('converting')
+  try {
+    const swfBuffer = await fs.readFile(/*turbopackIgnore: true*/ swfPath)
+    const result = convertSwfToNitro(swfBuffer, lib)
+    await fs.writeFile(/*turbopackIgnore: true*/ nitroPath, result.bundle)
+    if (result.warnings?.length) warnings.push(...result.warnings)
+  } catch (err) {
+    return {
+      ok: false,
+      lib,
+      warnings,
+      error: `SWF→Nitro conversion failed: ${(err as Error).message}`,
+    }
+  }
+
+  // Merge EffectMap.json (last step — no orphan entry if anything above failed)
+  onProgress?.('writing_map')
+  try {
+    const entry: EffectMapEntry = { id, lib, type, revision }
+    await mergeEffect(entry)
+  } catch (err) {
+    warnings.push(`EffectMap.json merge failed: ${(err as Error).message}`)
+    return { ok: false, lib, warnings, error: 'EffectMap.json merge failed' }
+  }
+
+  return { ok: true, lib, warnings }
+}
+
+export async function deleteImportedEffect(
+  idOrLib: string,
+): Promise<{ removed: boolean; deletedFile: boolean }> {
+  const local = await listLocalEffects()
+  const entry = local.find((e) => e.id === idOrLib || e.lib === idOrLib)
+  const removed = await removeEffect(idOrLib)
+  let deletedFile = false
+  if (entry) {
+    const p = nitroPathFor(entry.lib)
+    if (existsSync(/*turbopackIgnore: true*/ p)) {
+      await fs.unlink(/*turbopackIgnore: true*/ p).catch(() => {})
+      deletedFile = true
+    }
+  }
+  return { removed, deletedFile }
+}
+
+export async function getEffectList(search: string): Promise<EffectListItem[]> {
+  const [official, local] = await Promise.all([listOfficialEffects(), listLocalEffects()])
+  const localByLib = new Map(local.map((e) => [e.lib, e]))
+  const term = search.trim().toLowerCase()
+  const merged = official.map((e) => {
+    const present = localByLib.has(e.lib)
+    return {
+      ...e,
+      present,
+      nitroExists: existsSync(/*turbopackIgnore: true*/ nitroPathFor(e.lib)),
+    }
+  })
+  return term
+    ? merged.filter(
+        (e) =>
+          e.lib.toLowerCase().includes(term) ||
+          e.id.toLowerCase().includes(term) ||
+          e.type.includes(term),
+      )
+    : merged
+}
+
+export async function getEffectStats(): Promise<{
+  official: number
+  imported: number
+  missing: number
+}> {
+  const [official, local] = await Promise.all([listOfficialEffects(), listLocalEffects()])
+  const localLibs = new Set(local.map((e) => e.lib))
+  const imported = official.filter((e) => localLibs.has(e.lib)).length
+  return { official: official.length, imported, missing: official.length - imported }
+}
+