Spaces:
Running
Running
Download lib/galleryStore.ts from 2Btainment/Drip-Creator: direct link, hf CLI and curl.
- Browser
- Download file 7.69 kB
-
https://huggingface.co/spaces/2Btainment/Drip-Creator/resolve/main/lib/galleryStore.ts
- Command line
-
hf download hf://spaces/2Btainment/Drip-Creator/lib/galleryStore.ts
-
curl -L -o galleryStore.ts https://huggingface.co/spaces/2Btainment/Drip-Creator/resolve/main/lib/galleryStore.ts
7.69 kB
| /* ============================================================ | |
| * Galerie-Speicher: IndexedDB (unbegrenzt) mit localStorage-Migration | |
| * ============================================================ */ | |
| export type GalleryTag = "design" | "shop"; | |
| export interface GalleryImage { | |
| id: string; | |
| image: string; // base64 (ohne data:-Prefix) | |
| contentType: string; | |
| provider: string; | |
| model: string; | |
| tag: GalleryTag; | |
| addedAt: number; | |
| } | |
| export const toDataUrl = (img: { image: string; contentType?: string }) => | |
| `data:${img.contentType || "image/png"};base64,${img.image}`; | |
| const DB_NAME = "drip-gallery-db"; | |
| const DB_VERSION = 1; | |
| const STORE = "images"; | |
| function openDB(): Promise<IDBDatabase> { | |
| return new Promise((resolve, reject) => { | |
| const req = indexedDB.open(DB_NAME, DB_VERSION); | |
| req.onupgradeneeded = () => { | |
| const db = req.result; | |
| if (!db.objectStoreNames.contains(STORE)) { | |
| db.createObjectStore(STORE, { keyPath: "id" }); | |
| } | |
| }; | |
| req.onsuccess = () => resolve(req.result); | |
| req.onerror = () => reject(req.error || new Error("IndexedDB konnte nicht geöffnet werden.")); | |
| }); | |
| } | |
| async function withStore<T>(fn: (store: IDBObjectStore) => IDBRequest<T>): Promise<T> { | |
| const db = await openDB(); | |
| return new Promise<T>((resolve, reject) => { | |
| const tx = db.transaction(STORE, "readwrite"); | |
| const req = fn(tx.objectStore(STORE)); | |
| req.onsuccess = () => { | |
| resolve(req.result); | |
| // Nur schließen, wenn keine weiteren Requests anstehen | |
| tx.oncomplete = () => db.close(); | |
| }; | |
| req.onerror = () => { | |
| reject(req.error || new Error("IndexedDB-Operation fehlgeschlagen.")); | |
| db.close(); | |
| }; | |
| }); | |
| } | |
| /* ---------- Migration aus localStorage (einmalig) ---------- */ | |
| function migrateFromLocalStorage(): GalleryImage[] { | |
| try { | |
| const raw = localStorage.getItem("drip-gallery"); | |
| if (!raw) return []; | |
| const parsed = JSON.parse(raw); | |
| if (!Array.isArray(parsed)) return []; | |
| const migrated: GalleryImage[] = parsed | |
| .filter((x) => x && x.image) | |
| .map((x) => ({ | |
| id: `migrated-${crypto.randomUUID()}`, | |
| image: x.image, | |
| contentType: x.contentType || "image/png", | |
| provider: x.provider || "Migriert", | |
| model: x.model || "Design", | |
| tag: x.tag === "shop" ? "shop" : "design", | |
| addedAt: Date.now(), | |
| })); | |
| if (migrated.length > 0) { | |
| localStorage.removeItem("drip-gallery"); | |
| } | |
| return migrated; | |
| } catch { | |
| return []; | |
| } | |
| } | |
| /* ---------- Öffentliche API ---------- */ | |
| export async function galleryGetAll(): Promise<GalleryImage[]> { | |
| // Migration einmalig beim ersten Zugriff | |
| const migrated = migrateFromLocalStorage(); | |
| try { | |
| const db = await openDB(); | |
| const all = await new Promise<GalleryImage[]>((resolve, reject) => { | |
| const tx = db.transaction(STORE, "readonly"); | |
| const req = tx.objectStore(STORE).getAll(); | |
| req.onsuccess = () => resolve(req.result as GalleryImage[]); | |
| req.onerror = () => reject(req.error); | |
| tx.oncomplete = () => db.close(); | |
| }); | |
| if (migrated.length > 0) { | |
| await galleryAdd(migrated); | |
| return [...migrated, ...all]; | |
| } | |
| return all; | |
| } catch { | |
| return migrated; | |
| } | |
| } | |
| export async function galleryAdd(items: GalleryImage[]): Promise<void> { | |
| if (!items.length) return; | |
| try { | |
| const db = await openDB(); | |
| return await new Promise<void>((resolve, reject) => { | |
| const tx = db.transaction(STORE, "readwrite"); | |
| const store = tx.objectStore(STORE); | |
| for (const item of items) store.put(item); | |
| tx.oncomplete = () => { | |
| resolve(); | |
| db.close(); | |
| }; | |
| tx.onerror = () => { | |
| reject(tx.error); | |
| db.close(); | |
| }; | |
| }); | |
| } catch (e) { | |
| // IndexedDB nicht verfügbar (z. B. privater Modus) → still ignorieren | |
| console.warn("Galerie-Speicher nicht verfügbar:", e); | |
| } | |
| } | |
| export async function galleryRemove(ids: string[]): Promise<void> { | |
| if (!ids.length) return; | |
| try { | |
| const db = await openDB(); | |
| return await new Promise<void>((resolve, reject) => { | |
| const tx = db.transaction(STORE, "readwrite"); | |
| const store = tx.objectStore(STORE); | |
| for (const id of ids) store.delete(id); | |
| tx.oncomplete = () => { | |
| resolve(); | |
| db.close(); | |
| }; | |
| tx.onerror = () => { | |
| reject(tx.error); | |
| db.close(); | |
| }; | |
| }); | |
| } catch { | |
| /* ignorieren */ | |
| } | |
| } | |
| export async function galleryUpdate(id: string, patch: Partial<GalleryImage>): Promise<void> { | |
| try { | |
| const db = await openDB(); | |
| return await new Promise<void>((resolve, reject) => { | |
| const tx = db.transaction(STORE, "readwrite"); | |
| const store = tx.objectStore(STORE); | |
| const req = store.get(id); | |
| req.onsuccess = () => { | |
| const existing = req.result as GalleryImage | undefined; | |
| if (existing) store.put({ ...existing, ...patch }); | |
| }; | |
| tx.oncomplete = () => { | |
| resolve(); | |
| db.close(); | |
| }; | |
| tx.onerror = () => { | |
| reject(tx.error); | |
| db.close(); | |
| }; | |
| }); | |
| } catch { | |
| /* ignorieren */ | |
| } | |
| } | |
| /** Aktive Auswahl fürs Studio merken (Galerie → Workspace) */ | |
| export function setStudioSelection(img: GalleryImage) { | |
| try { | |
| sessionStorage.setItem("drip-selected", JSON.stringify(img)); | |
| } catch { | |
| /* ignorieren */ | |
| } | |
| } | |
| export function takeStudioSelection(): GalleryImage | null { | |
| try { | |
| const raw = sessionStorage.getItem("drip-selected"); | |
| if (!raw) return null; | |
| sessionStorage.removeItem("drip-selected"); | |
| return JSON.parse(raw) as GalleryImage; | |
| } catch { | |
| return null; | |
| } | |
| } | |
| /* ---------- Bildverarbeitung (Upload) ---------- */ | |
| export async function fileToDataUrl(file: File): Promise<string> { | |
| return new Promise((resolve, reject) => { | |
| const reader = new FileReader(); | |
| reader.onload = () => resolve(reader.result as string); | |
| reader.onerror = () => reject(new Error("Datei konnte nicht gelesen werden.")); | |
| reader.readAsDataURL(file); | |
| }); | |
| } | |
| /** Bild verkleinern (max. Kantenlänge) → JPEG-DataURL (base64 ohne Prefix) */ | |
| export async function resizeImage( | |
| dataUrl: string, | |
| max = 1024, | |
| quality = 0.85 | |
| ): Promise<{ data: string; contentType: string }> { | |
| return new Promise((resolve, reject) => { | |
| const img = new Image(); | |
| img.onload = () => { | |
| try { | |
| const scale = Math.min(1, max / Math.max(img.naturalWidth, img.naturalHeight)); | |
| const canvas = document.createElement("canvas"); | |
| canvas.width = Math.max(1, Math.round(img.naturalWidth * scale)); | |
| canvas.height = Math.max(1, Math.round(img.naturalHeight * scale)); | |
| const ctx = canvas.getContext("2d"); | |
| if (!ctx) throw new Error("Canvas nicht verfügbar."); | |
| ctx.drawImage(img, 0, 0, canvas.width, canvas.height); | |
| const out = canvas.toDataURL("image/jpeg", quality); | |
| resolve({ data: out.split(",")[1] || out, contentType: "image/jpeg" }); | |
| } catch (e) { | |
| reject(e); | |
| } | |
| }; | |
| img.onerror = () => reject(new Error("Bild konnte nicht geladen werden.")); | |
| img.src = dataUrl; | |
| }); | |
| } | |
| /** Datei → Galerie-Bild (verkleinert) */ | |
| export async function fileToGalleryImage(file: File, tag: GalleryTag): Promise<GalleryImage> { | |
| const dataUrl = await fileToDataUrl(file); | |
| const resized = await resizeImage(dataUrl); | |
| return { | |
| id: crypto.randomUUID(), | |
| image: resized.data, | |
| contentType: resized.contentType, | |
| provider: tag === "design" ? "Upload (Design)" : "Upload (Shop-Foto)", | |
| model: file.name || (tag === "design" ? "Design" : "Shop-Foto"), | |
| tag, | |
| addedAt: Date.now(), | |
| }; | |
| } | |