Drip-Creator / lib /galleryStore.ts
Alexander Canji
fix(space): Docker SDK auf Port 7860, Secrets entfernt, PWA + API-Härtung
19e93fc
Raw History Blame Contribute Delete
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(),
};
}