@drawnagency/primitives 0.1.0

package/dist/hooks/useMediaPipeline.js

@@ -0,0 +1,253 @@
+import { useState, useCallback, useEffect, useRef, useMemo } from "react";
+import { hashFileBuffer, sanitizeMediaName } from "../media/utils";
+import { ProcessingQueue } from "../media/queue";
+import { addPendingMediaItem, markPendingMediaDeleted, } from "../lib/dexie";
+import { generateVideoPoster } from "../media/videoPoster";
+function clearImageIds(obj, ids) {
+    if (Array.isArray(obj))
+        return obj.map((item) => clearImageIds(item, ids));
+    if (obj !== null && typeof obj === "object") {
+        const record = obj;
+        const result = {};
+        for (const [key, value] of Object.entries(record)) {
+            if (key === "imageId" && typeof value === "string" && ids.has(value)) {
+                result[key] = "";
+            }
+            else {
+                result[key] = clearImageIds(value, ids);
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+export function useMediaPipeline({ siteConfig, mediaManifest, setMediaManifest, sections, setSections, setLocalChangesExist, setDirtySectionIds, markSectionDirty, }) {
+    const [processingItems, setProcessingItems] = useState([]);
+    const [pendingMediaItems, setPendingMediaItems] = useState([]);
+    const [pendingLocalUrls, setPendingLocalUrls] = useState({});
+    const [pendingDeletions, setPendingDeletions] = useState([]);
+    const queueRef = useRef(null);
+    const uploadCallbacksRef = useRef(new Map());
+    // --- Processing queue ---
+    const mediaConfigKey = siteConfig
+        ? `${siteConfig.media.sizes.join(",")}_${siteConfig.media.quality}_${siteConfig.media.maxFileSize}`
+        : "";
+    useEffect(() => {
+        if (!siteConfig)
+            return;
+        const mediaConfig = siteConfig.media;
+        const queue = new ProcessingQueue({
+            sizes: mediaConfig.sizes,
+            quality: mediaConfig.quality,
+            maxConcurrent: 3,
+            createWorker: () => new Worker(new URL("../media/worker.ts", import.meta.url), { type: "module" }),
+            onEvent: (event) => {
+                setProcessingItems((prev) => {
+                    const next = prev.filter((i) => i.id !== event.item.id);
+                    if (event.item.state !== "complete")
+                        next.push(event.item);
+                    return next;
+                });
+                if (event.type === "complete" && event.item.result) {
+                    const result = event.item.result;
+                    const kind = event.item.kind;
+                    const sanitizedName = sanitizeMediaName(event.item.originalName);
+                    const finalize = (localUrls, width, height) => {
+                        const item = {
+                            id: event.item.hash,
+                            hash: event.item.hash,
+                            kind,
+                            originalName: sanitizedName,
+                            width,
+                            height,
+                            mimeType: kind === "image" ? "image/webp" : event.item.mimeType,
+                            size: result.primaryBlob.size,
+                            folder: `${sanitizedName}-${event.item.hash}`,
+                            variants: result.variants.map((v) => ({
+                                width: v.width,
+                                height: v.height,
+                                size: v.size,
+                            })),
+                            alt: "",
+                        };
+                        addPendingMediaItem(item, localUrls);
+                        setPendingMediaItems((prev) => [...prev, item]);
+                        const displayKey = kind === "video"
+                            ? "primary"
+                            : Object.keys(localUrls).find((k) => k !== "primary" && k !== "poster") ?? "primary";
+                        if (localUrls[displayKey]) {
+                            setPendingLocalUrls((prev) => ({ ...prev, [item.id]: localUrls[displayKey] }));
+                        }
+                        setLocalChangesExist(true);
+                        const callback = uploadCallbacksRef.current.get(event.item.hash);
+                        if (callback) {
+                            callback(event.item.hash);
+                            uploadCallbacksRef.current.delete(event.item.hash);
+                        }
+                    };
+                    const localUrls = {};
+                    for (const v of result.variants) {
+                        localUrls[String(v.width)] = URL.createObjectURL(v.blob);
+                    }
+                    if (result.primaryBlob) {
+                        localUrls["primary"] = URL.createObjectURL(result.primaryBlob);
+                    }
+                    if (kind === "video") {
+                        generateVideoPoster(result.primaryBlob, mediaConfig.quality).then(({ posterBlob, width, height }) => {
+                            localUrls["poster"] = URL.createObjectURL(posterBlob);
+                            finalize(localUrls, width, height);
+                        }, () => {
+                            finalize(localUrls, result.width, result.height);
+                        });
+                    }
+                    else {
+                        if (result.posterBlob) {
+                            localUrls["poster"] = URL.createObjectURL(result.posterBlob);
+                        }
+                        finalize(localUrls, result.width, result.height);
+                    }
+                }
+            },
+        });
+        queueRef.current = queue;
+        return () => queue.destroy();
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- rebuild only when processing params change, not on every siteConfig reference change
+    }, [mediaConfigKey, setLocalChangesExist]);
+    // --- Media handlers ---
+    const handleMediaUpload = useCallback(async (files) => {
+        if (!siteConfig)
+            return;
+        const mediaConfig = siteConfig.media;
+        const queue = queueRef.current;
+        if (!queue)
+            return;
+        for (const file of files) {
+            if (file.size > mediaConfig.maxFileSize)
+                continue;
+            const buffer = await file.arrayBuffer();
+            const hash = await hashFileBuffer(buffer);
+            const existsInManifest = hash in mediaManifest.images;
+            const existsInPending = pendingMediaItems.some((i) => i.hash === hash);
+            if (existsInManifest || existsInPending)
+                continue;
+            let kind = "image";
+            if (file.type === "image/gif" || file.type === "image/apng")
+                kind = "animated";
+            if (file.type.startsWith("video/"))
+                kind = "video";
+            queue.add({ buffer, originalName: file.name, mimeType: file.type, hash, kind });
+        }
+    }, [siteConfig, mediaManifest, pendingMediaItems]);
+    const handleMediaDelete = useCallback(async (ids) => {
+        for (const id of ids) {
+            await markPendingMediaDeleted(id);
+        }
+        setPendingDeletions((prev) => [...prev, ...ids]);
+        const idSet = new Set(ids);
+        setSections((prev) => prev.map((loaded) => {
+            const json = JSON.stringify(loaded.section);
+            const hasRef = ids.some((id) => json.includes(`"${id}"`));
+            if (!hasRef)
+                return loaded;
+            const cleared = clearImageIds(loaded.section, idSet);
+            markSectionDirty(loaded.section.id, cleared);
+            setDirtySectionIds((prev) => new Set(prev).add(loaded.section.id));
+            return { ...loaded, section: { id: loaded.section.id, ...cleared } };
+        }));
+        setLocalChangesExist(true);
+    }, [markSectionDirty, setSections, setDirtySectionIds, setLocalChangesExist]);
+    const handleMediaAltChange = useCallback((id, alt) => {
+        setMediaManifest((prev) => {
+            const item = prev.images[id];
+            if (!item)
+                return prev;
+            return { images: { ...prev.images, [id]: { ...item, alt } } };
+        });
+        setPendingMediaItems((prev) => prev.map((item) => (item.id === id ? { ...item, alt } : item)));
+        setLocalChangesExist(true);
+    }, [setMediaManifest, setLocalChangesExist]);
+    const referenceCountMap = useMemo(() => {
+        const counts = {};
+        const allIds = [
+            ...Object.keys(mediaManifest.images),
+            ...pendingMediaItems.map((i) => i.id),
+        ];
+        for (const { section } of sections) {
+            const json = JSON.stringify(section);
+            for (const id of allIds) {
+                const regex = new RegExp(`"imageId"\\s*:\\s*"${id}"`, "g");
+                const matches = json.match(regex);
+                if (matches)
+                    counts[id] = (counts[id] ?? 0) + matches.length;
+            }
+        }
+        return counts;
+    }, [sections, mediaManifest, pendingMediaItems]);
+    // --- Unified enqueue ---
+    const enqueueFile = useCallback((file, onComplete) => {
+        if (!siteConfig)
+            return;
+        const mediaConfig = siteConfig.media;
+        if (file.size > mediaConfig.maxFileSize)
+            return;
+        (async () => {
+            try {
+                const buffer = await file.arrayBuffer();
+                const hash = await hashFileBuffer(buffer);
+                const existsInManifest = hash in mediaManifest.images;
+                const existsInPending = pendingMediaItems.some((i) => i.hash === hash);
+                if (existsInManifest || existsInPending) {
+                    if (onComplete)
+                        onComplete(hash);
+                    return;
+                }
+                if (onComplete) {
+                    uploadCallbacksRef.current.set(hash, onComplete);
+                }
+                let kind = "image";
+                if (file.type === "image/gif" || file.type === "image/apng")
+                    kind = "animated";
+                if (file.type.startsWith("video/"))
+                    kind = "video";
+                queueRef.current?.add({ buffer, originalName: file.name, mimeType: file.type, hash, kind });
+            }
+            catch (err) {
+                console.error(`[useMediaPipeline] Failed to enqueue file "${file.name}":`, err);
+            }
+        })();
+    }, [siteConfig, mediaManifest, pendingMediaItems]);
+    // --- Context value ---
+    const contextValue = useMemo(() => ({
+        openSelectModal: () => {
+            // Placeholder — EditorShell overrides this
+        },
+        uploadFile: (file) => handleMediaUpload([file]),
+        uploadFileWithCallback: (file, onComplete) => {
+            const blobUrl = URL.createObjectURL(file);
+            enqueueFile(file, (imageId) => {
+                URL.revokeObjectURL(blobUrl);
+                onComplete(imageId);
+            });
+            return blobUrl;
+        },
+        manifest: mediaManifest,
+        pendingItems: pendingMediaItems,
+        pendingLocalUrls: pendingLocalUrls,
+        siteConfig,
+    }), [handleMediaUpload, enqueueFile, mediaManifest, pendingMediaItems, pendingLocalUrls, siteConfig]);
+    return {
+        processingItems,
+        pendingMediaItems,
+        setPendingMediaItems,
+        pendingLocalUrls,
+        setPendingLocalUrls,
+        pendingDeletions,
+        setPendingDeletions,
+        handleMediaUpload,
+        handleMediaDelete,
+        handleMediaAltChange,
+        referenceCountMap,
+        contextValue,
+        enqueueFile,
+    };
+}

package/dist/hooks/useResolvedMedia.d.ts

@@ -0,0 +1,9 @@
+export interface ResolvedMediaResult {
+    src: string | undefined;
+    srcset: string | undefined;
+    poster: string | undefined;
+    alt: string;
+    kind: "image" | "animated" | "video";
+}
+export declare function useResolvedMedia(imageId: string | undefined): ResolvedMediaResult;
+//# sourceMappingURL=useResolvedMedia.d.ts.map

package/dist/hooks/useResolvedMedia.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResolvedMedia.d.ts","sourceRoot":"","sources":["../../src/hooks/useResolvedMedia.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,OAAO,GAAG,UAAU,GAAG,OAAO,CAAC;CACtC;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,mBAAmB,CAyCjF"}

package/dist/hooks/useResolvedMedia.js

@@ -0,0 +1,39 @@
+import { useMemo } from "react";
+import { useMediaLibrary } from "../components/shell/MediaLibraryContext";
+import { createMediaAdapter } from "../media";
+export function useResolvedMedia(imageId) {
+    const ctx = useMediaLibrary();
+    return useMemo(() => {
+        if (!imageId || !ctx) {
+            return { src: undefined, srcset: undefined, poster: undefined, alt: "", kind: "image" };
+        }
+        const { manifest, pendingItems, pendingLocalUrls, siteConfig } = ctx;
+        const sizes = siteConfig?.media?.sizes ?? [640, 1080, 1920];
+        const manifestItem = manifest.images[imageId];
+        const pendingItem = pendingItems.find((i) => i.id === imageId);
+        const item = manifestItem ?? pendingItem;
+        const alt = item?.alt ?? "";
+        const kind = item?.kind ?? "image";
+        const localUrl = pendingLocalUrls[imageId];
+        if (localUrl) {
+            return { src: localUrl, srcset: undefined, poster: undefined, alt, kind };
+        }
+        if (manifestItem) {
+            const adapter = createMediaAdapter(manifest);
+            const resolved = adapter.resolve(imageId, sizes);
+            if (resolved && resolved.tag === "img") {
+                return {
+                    src: resolved.src,
+                    srcset: "srcSet" in resolved ? resolved.srcSet : undefined,
+                    poster: undefined,
+                    alt,
+                    kind,
+                };
+            }
+            if (resolved && resolved.tag === "video") {
+                return { src: resolved.src, srcset: undefined, poster: resolved.poster, alt, kind };
+            }
+        }
+        return { src: undefined, srcset: undefined, poster: undefined, alt, kind };
+    }, [imageId, ctx]);
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./schemas";
+export * from "./lib";
+export * from "./auth";
+export * from "./media";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./schemas";
+export * from "./lib";
+export * from "./auth";
+export * from "./media";

package/dist/lib/cn.d.ts

@@ -0,0 +1,3 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;
+//# sourceMappingURL=cn.d.ts.map

package/dist/lib/cn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cn.d.ts","sourceRoot":"","sources":["../../src/lib/cn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,MAAM,CAAC;AAG7C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC"}

package/dist/lib/cn.js

@@ -0,0 +1,5 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist/lib/contrast.d.ts

@@ -0,0 +1,2 @@
+export declare function deriveContrast(hex: string): string;
+//# sourceMappingURL=contrast.d.ts.map

package/dist/lib/contrast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contrast.d.ts","sourceRoot":"","sources":["../../src/lib/contrast.ts"],"names":[],"mappings":"AAAA,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAUlD"}

package/dist/lib/contrast.js

@@ -0,0 +1,11 @@
+export function deriveContrast(hex) {
+    const h = hex.replace("#", "");
+    const expanded = h.length === 3
+        ? h[0] + h[0] + h[1] + h[1] + h[2] + h[2]
+        : h;
+    const r = parseInt(expanded.substring(0, 2), 16);
+    const g = parseInt(expanded.substring(2, 4), 16);
+    const b = parseInt(expanded.substring(4, 6), 16);
+    const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+    return luminance >= 0.5 ? "#1a1a1a" : "#f0f0f0";
+}

package/dist/lib/dexie.d.ts

@@ -0,0 +1,41 @@
+import type { SectionContent } from "../schemas/sections";
+import type { SiteIndex } from "../schemas/site-config";
+import type { LoadedSection } from "./loader";
+import type { MediaManifest, MediaItem } from "../media/types";
+export declare function initEditorStore(siteId: string): void;
+export declare function checkForLocalChanges(): Promise<{
+    latestTimestamp: string;
+} | null>;
+export declare function restoreLocalChanges(): Promise<{
+    sections: Record<string, SectionContent>;
+    siteIndex?: SiteIndex;
+    siteConfig?: Record<string, unknown>;
+}>;
+export declare function discardLocalChanges(): Promise<void>;
+export declare function persistSiteIndex(index: SiteIndex): Promise<void>;
+export declare function persistSiteConfig(config: Record<string, unknown>): Promise<void>;
+export declare function hasLocalChanges(): Promise<boolean>;
+export declare function getDirtySections(): Promise<{
+    sectionId: string;
+    content: SectionContent;
+}[]>;
+export declare function persistAll(sections: {
+    sectionId: string;
+    content: SectionContent;
+}[], siteIndex?: SiteIndex, deletedSectionIds?: string[], siteConfig?: Record<string, unknown>): Promise<void>;
+export declare function cacheContent(sha: string, sections: LoadedSection[], index: SiteIndex, siteConfig: Record<string, unknown>): Promise<void>;
+export declare function getCachedContent(): Promise<{
+    sha: string;
+    sections: LoadedSection[];
+    index: SiteIndex;
+    siteConfig: Record<string, unknown>;
+} | null>;
+export declare function persistMediaManifest(manifest: MediaManifest): Promise<void>;
+export declare function getMediaManifest(): Promise<MediaManifest | null>;
+export declare function addPendingMediaItem(item: MediaItem, localUrls?: Record<string, string>): Promise<void>;
+export declare function getPendingMediaItems(): Promise<MediaItem[]>;
+export declare function getPendingMediaLocalUrls(id: string): Promise<Record<string, string> | null>;
+export declare function markPendingMediaDeleted(id: string): Promise<void>;
+export declare function getPendingMediaDeletions(): Promise<string[]>;
+export declare function clearPendingMedia(): Promise<void>;
+//# sourceMappingURL=dexie.d.ts.map

package/dist/lib/dexie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dexie.d.ts","sourceRoot":"","sources":["../../src/lib/dexie.ts"],"names":[],"mappings":"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"}

package/dist/lib/dexie.js

@@ -0,0 +1,236 @@
+import Dexie from "dexie";
+class EditorDatabase extends Dexie {
+    sections;
+    siteIndex;
+    meta;
+    siteConfig;
+    contentCache;
+    mediaManifest;
+    pendingMedia;
+    pendingMediaDeletions;
+    constructor(siteId) {
+        super(`brand-portal-${siteId}`);
+        this.version(1).stores({
+            sections: "sectionId",
+            siteIndex: "key",
+            meta: "key",
+        });
+        this.version(2).stores({
+            sections: "sectionId",
+            siteIndex: "key",
+            meta: "key",
+            siteConfig: "key",
+        });
+        this.version(3).stores({
+            sections: "sectionId",
+            siteIndex: "key",
+            meta: "key",
+            siteConfig: "key",
+            contentCache: "key",
+        });
+        this.version(4).stores({
+            sections: "sectionId",
+            siteIndex: "key",
+            meta: "key",
+            siteConfig: "key",
+            contentCache: "key",
+            mediaManifest: "key",
+            pendingMedia: "id",
+            pendingMediaDeletions: "id",
+        });
+    }
+}
+let db = null;
+function getDb() {
+    if (!db)
+        throw new Error("Editor store not initialized. Call initEditorStore first.");
+    return db;
+}
+export function initEditorStore(siteId) {
+    db = new EditorDatabase(siteId);
+}
+export async function checkForLocalChanges() {
+    const database = getDb();
+    const dirtyRows = await database.sections.filter((row) => row.dirty).toArray();
+    const indexRow = await database.siteIndex.get("current");
+    const configRow = await database.siteConfig.get("current");
+    if (dirtyRows.length === 0 && !indexRow && !configRow)
+        return null;
+    const timestamps = [];
+    for (const row of dirtyRows)
+        timestamps.push(row.updatedAt);
+    if (indexRow)
+        timestamps.push(indexRow.updatedAt);
+    if (configRow)
+        timestamps.push(configRow.updatedAt);
+    timestamps.sort();
+    return { latestTimestamp: timestamps[timestamps.length - 1] };
+}
+export async function restoreLocalChanges() {
+    const sectionRows = await getDb().sections.toArray();
+    const sections = {};
+    for (const row of sectionRows) {
+        sections[row.sectionId] = row.content;
+    }
+    const indexRow = await getDb().siteIndex.get("current");
+    const configRow = await getDb().siteConfig.get("current");
+    if (indexRow) {
+        const metaRow = await getDb().meta.get("current");
+        const siteId = metaRow?.siteId ?? "";
+        return {
+            sections,
+            siteIndex: { siteId, order: indexRow.order, sections: indexRow.sections },
+            siteConfig: configRow?.config,
+        };
+    }
+    return { sections, siteIndex: undefined, siteConfig: configRow?.config };
+}
+export async function discardLocalChanges() {
+    const database = getDb();
+    await database.transaction("rw", [database.sections, database.siteIndex, database.meta, database.siteConfig, database.pendingMedia, database.pendingMediaDeletions, database.mediaManifest], async () => {
+        await database.sections.clear();
+        await database.siteIndex.clear();
+        await database.meta.clear();
+        await database.siteConfig.clear();
+        await database.pendingMedia.clear();
+        await database.pendingMediaDeletions.clear();
+        await database.mediaManifest.clear();
+    });
+}
+export async function persistSiteIndex(index) {
+    const now = new Date().toISOString();
+    const database = getDb();
+    await database.transaction("rw", [database.siteIndex, database.meta], async () => {
+        await database.siteIndex.put({
+            key: "current",
+            order: index.order,
+            sections: index.sections,
+            updatedAt: now,
+        });
+        await database.meta.put({
+            key: "current",
+            lastSavedSha: null,
+            lastSavedAt: null,
+            siteId: index.siteId,
+        });
+    });
+}
+export async function persistSiteConfig(config) {
+    const now = new Date().toISOString();
+    const database = getDb();
+    await database.siteConfig.put({
+        key: "current",
+        config,
+        updatedAt: now,
+    });
+}
+export async function hasLocalChanges() {
+    const database = getDb();
+    const dirtyCount = await database.sections.filter((row) => row.dirty).count();
+    if (dirtyCount > 0)
+        return true;
+    const indexRow = await database.siteIndex.get("current");
+    if (indexRow != null)
+        return true;
+    const configRow = await database.siteConfig.get("current");
+    return configRow != null;
+}
+export async function getDirtySections() {
+    const rows = await getDb().sections.filter((row) => row.dirty).toArray();
+    return rows.map((row) => ({ sectionId: row.sectionId, content: row.content }));
+}
+export async function persistAll(sections, siteIndex, deletedSectionIds, siteConfig) {
+    const now = new Date().toISOString();
+    const database = getDb();
+    await database.transaction("rw", [database.sections, database.siteIndex, database.meta, database.siteConfig], async () => {
+        if (sections.length > 0) {
+            await database.sections.bulkPut(sections.map((e) => ({
+                sectionId: e.sectionId,
+                content: e.content,
+                dirty: true,
+                updatedAt: now,
+            })));
+        }
+        if (deletedSectionIds && deletedSectionIds.length > 0) {
+            await database.sections.bulkDelete(deletedSectionIds);
+        }
+        if (siteIndex) {
+            await database.siteIndex.put({
+                key: "current",
+                order: siteIndex.order,
+                sections: siteIndex.sections,
+                updatedAt: now,
+            });
+            await database.meta.put({
+                key: "current",
+                lastSavedSha: null,
+                lastSavedAt: null,
+                siteId: siteIndex.siteId,
+            });
+        }
+        if (siteConfig) {
+            await database.siteConfig.put({
+                key: "current",
+                config: siteConfig,
+                updatedAt: now,
+            });
+        }
+    });
+}
+export async function cacheContent(sha, sections, index, siteConfig) {
+    const now = new Date().toISOString();
+    await getDb().contentCache.put({
+        key: "current",
+        sha,
+        sections,
+        index,
+        siteConfig,
+        updatedAt: now,
+    });
+}
+export async function getCachedContent() {
+    const row = await getDb().contentCache.get("current");
+    if (!row)
+        return null;
+    return {
+        sha: row.sha,
+        sections: row.sections,
+        index: row.index,
+        siteConfig: row.siteConfig,
+    };
+}
+export async function persistMediaManifest(manifest) {
+    const now = new Date().toISOString();
+    await getDb().mediaManifest.put({ key: "current", manifest, updatedAt: now });
+}
+export async function getMediaManifest() {
+    const row = await getDb().mediaManifest.get("current");
+    return row?.manifest ?? null;
+}
+export async function addPendingMediaItem(item, localUrls = {}) {
+    const now = new Date().toISOString();
+    await getDb().pendingMedia.put({ id: item.id, item, localUrls, updatedAt: now });
+}
+export async function getPendingMediaItems() {
+    const rows = await getDb().pendingMedia.toArray();
+    return rows.map((r) => r.item);
+}
+export async function getPendingMediaLocalUrls(id) {
+    const row = await getDb().pendingMedia.get(id);
+    return row?.localUrls ?? null;
+}
+export async function markPendingMediaDeleted(id) {
+    const now = new Date().toISOString();
+    await getDb().pendingMediaDeletions.put({ id, deletedAt: now });
+}
+export async function getPendingMediaDeletions() {
+    const rows = await getDb().pendingMediaDeletions.toArray();
+    return rows.map((r) => r.id);
+}
+export async function clearPendingMedia() {
+    const database = getDb();
+    await database.transaction("rw", [database.pendingMedia, database.pendingMediaDeletions], async () => {
+        await database.pendingMedia.clear();
+        await database.pendingMediaDeletions.clear();
+    });
+}

package/dist/lib/events.d.ts

@@ -0,0 +1,12 @@
+import type { NavItem } from "./nav";
+export interface TypedEvent<T> {
+    dispatch(detail: T): void;
+    listen(callback: (detail: T) => void): () => void;
+}
+export declare function createEvent<T>(name: string): TypedEvent<T>;
+export declare const editModeEvent: TypedEvent<{
+    isEditMode: boolean;
+}>;
+export declare const navChangeEvent: TypedEvent<NavItem[]>;
+export declare const darkModeEvent: TypedEvent<string>;
+//# sourceMappingURL=events.d.ts.map

package/dist/lib/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/lib/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAErC,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC;IAC1B,MAAM,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CACnD;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,CAW1D;AAED,eAAO,MAAM,aAAa;gBAA6B,OAAO;EAAqB,CAAC;AACpF,eAAO,MAAM,cAAc,uBAA0C,CAAC;AACtE,eAAO,MAAM,aAAa,oBAAsC,CAAC"}