@drawnagency/primitives 0.1.1 → 0.2.0

package/dist/hooks/index.js

@@ -1,6 +0,0 @@
-export { useActiveHeadings } from "./useActiveHeadings";
-export { useEditorPersistence } from "./useEditorPersistence";
-export { useEditorPublish } from "./useEditorPublish";
-export { useFocusTrap } from "./useFocusTrap";
-export { useMediaPipeline } from "./useMediaPipeline";
-export { useResolvedMedia } from "./useResolvedMedia";

package/dist/hooks/useActiveHeadings.js

@@ -1,99 +0,0 @@
-import { useEffect, useMemo, useRef, useState, useCallback } from "react";
-export function useActiveHeadings(parentIds, childIdsByParent, grandchildIdsByChild, headerOffset = 80) {
-    const [activeParentId, setActiveParentId] = useState("");
-    const [activeChildId, setActiveChildId] = useState("");
-    const [activeGrandchildId, setActiveGrandchildId] = useState("");
-    const childKey = useMemo(() => Object.entries(childIdsByParent).map(([k, v]) => `${k}:${v.join(",")}`).join("|"), [childIdsByParent]);
-    const grandchildKey = useMemo(() => Object.entries(grandchildIdsByChild).map(([k, v]) => `${k}:${v.join(",")}`).join("|"), [grandchildIdsByChild]);
-    // Use refs for comparison inside the effect to avoid re-render loops
-    const activeParentRef = useRef("");
-    const activeChildRef = useRef("");
-    const activeGrandchildRef = useRef("");
-    const ticking = useRef(false);
-    const transitionTimeoutRef = useRef(null);
-    useEffect(() => {
-        if (parentIds.length === 0)
-            return;
-        let parentEls = [];
-        const collect = () => {
-            parentEls = parentIds
-                .map((id) => ({ id, el: document.getElementById(id) }))
-                .filter((x) => !!x.el);
-        };
-        collect();
-        const findActive = (ids) => {
-            let active = "";
-            for (const id of ids) {
-                const el = document.getElementById(id);
-                if (!el)
-                    continue;
-                if (el.getBoundingClientRect().top - headerOffset <= 0)
-                    active = id;
-                else
-                    break;
-            }
-            return active;
-        };
-        const computeActive = () => {
-            const parent = findActive(parentIds) || parentEls[0]?.id || "";
-            if (!parent)
-                return;
-            if (activeParentRef.current !== parent) {
-                if (transitionTimeoutRef.current)
-                    clearTimeout(transitionTimeoutRef.current);
-                if (activeParentRef.current) {
-                    // Delay parent transitions to prevent flashing
-                    transitionTimeoutRef.current = setTimeout(() => {
-                        activeParentRef.current = parent;
-                        setActiveParentId(parent);
-                    }, 250);
-                }
-                else {
-                    activeParentRef.current = parent;
-                    setActiveParentId(parent);
-                }
-            }
-            const child = findActive(childIdsByParent[parent] || []);
-            if (activeChildRef.current !== child) {
-                activeChildRef.current = child;
-                setActiveChildId(child);
-            }
-            const grandchild = findActive(grandchildIdsByChild[child] || []);
-            if (activeGrandchildRef.current !== grandchild) {
-                activeGrandchildRef.current = grandchild;
-                setActiveGrandchildId(grandchild);
-            }
-        };
-        const onScroll = () => {
-            if (!ticking.current) {
-                ticking.current = true;
-                requestAnimationFrame(() => {
-                    computeActive();
-                    ticking.current = false;
-                });
-            }
-        };
-        const onResize = () => {
-            collect();
-            computeActive();
-        };
-        window.addEventListener("scroll", onScroll, { passive: true });
-        window.addEventListener("resize", onResize);
-        // Initial compute
-        computeActive();
-        return () => {
-            window.removeEventListener("scroll", onScroll);
-            window.removeEventListener("resize", onResize);
-            if (transitionTimeoutRef.current)
-                clearTimeout(transitionTimeoutRef.current);
-        };
-        // Only stable values in dep array — NO state variables
-    }, [parentIds.join("|"), childKey, grandchildKey, headerOffset]);
-    const setActiveSection = useCallback((id) => {
-        const newHash = `#${id}`;
-        if (window.location.hash !== newHash) {
-            window.history.replaceState(null, "", newHash);
-        }
-    }, []);
-    return { activeParentId, activeChildId, activeGrandchildId, setActiveSection };
-}

package/dist/hooks/useEditorPersistence.js

@@ -1,73 +0,0 @@
-import { useCallback, useRef, useEffect } from "react";
-import { persistAll, persistSiteConfig } from "../lib/dexie";
-export function useEditorPersistence(siteIndexRef) {
-    const state = useRef({
-        pendingSections: new Map(),
-        pendingDeletes: new Set(),
-        indexDirty: false,
-        configDirty: false,
-    });
-    const flushTimerRef = useRef(null);
-    const flushToDexie = useCallback(async () => {
-        const s = state.current;
-        if (s.pendingSections.size === 0 && !s.indexDirty && s.pendingDeletes.size === 0)
-            return;
-        const entries = Array.from(s.pendingSections.entries()).map(([sectionId, content]) => ({
-            sectionId,
-            content,
-        }));
-        const deletedIds = Array.from(s.pendingDeletes);
-        s.pendingSections = new Map();
-        s.pendingDeletes = new Set();
-        const wasIndexDirty = s.indexDirty;
-        s.indexDirty = false;
-        await persistAll(entries, wasIndexDirty ? siteIndexRef.current : undefined, deletedIds.length > 0 ? deletedIds : undefined);
-    }, [siteIndexRef]);
-    const scheduleFlush = useCallback(() => {
-        if (flushTimerRef.current)
-            clearTimeout(flushTimerRef.current);
-        flushTimerRef.current = setTimeout(flushToDexie, 500);
-    }, [flushToDexie]);
-    useEffect(() => {
-        return () => {
-            if (flushTimerRef.current)
-                clearTimeout(flushTimerRef.current);
-        };
-    }, []);
-    const markSectionDirty = useCallback((sectionId, content) => {
-        state.current.pendingSections.set(sectionId, content);
-        scheduleFlush();
-    }, [scheduleFlush]);
-    const markSectionDeleted = useCallback((sectionId) => {
-        state.current.pendingSections.delete(sectionId);
-        state.current.pendingDeletes.add(sectionId);
-        state.current.indexDirty = true;
-        scheduleFlush();
-    }, [scheduleFlush]);
-    const markIndexDirty = useCallback(() => {
-        state.current.indexDirty = true;
-        scheduleFlush();
-    }, [scheduleFlush]);
-    const persistConfig = useCallback(async (config) => {
-        state.current.configDirty = true;
-        await persistSiteConfig(config);
-    }, []);
-    const cancelPendingFlush = useCallback(() => {
-        if (flushTimerRef.current) {
-            clearTimeout(flushTimerRef.current);
-            flushTimerRef.current = null;
-        }
-    }, []);
-    const isConfigDirty = useCallback(() => state.current.configDirty, []);
-    const clearConfigDirty = useCallback(() => { state.current.configDirty = false; }, []);
-    return {
-        markSectionDirty,
-        markSectionDeleted,
-        markIndexDirty,
-        persistConfig,
-        flushNow: flushToDexie,
-        cancelPendingFlush,
-        isConfigDirty,
-        clearConfigDirty,
-    };
-}

package/dist/hooks/useEditorPublish.js

@@ -1,145 +0,0 @@
-import { useState, useCallback, useRef, useEffect } from "react";
-import { getDirtySections, hasLocalChanges, discardLocalChanges, cacheContent, getPendingMediaLocalUrls, clearPendingMedia } from "../lib/dexie";
-function blobToBase64(blob) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = () => {
-            const dataUrl = reader.result;
-            resolve(dataUrl.split(",")[1]);
-        };
-        reader.onerror = reject;
-        reader.readAsDataURL(blob);
-    });
-}
-export function useEditorPublish({ flushNow, cancelPendingFlush, isConfigDirty, clearConfigDirty, siteIndexRef, siteConfig, sections, onSuccess, mediaManifest, pendingMediaItems, pendingMediaDeletions, onMediaPublished, }) {
-    const [isPublishing, setIsPublishing] = useState(false);
-    const [publishFeedback, setPublishFeedback] = useState(null);
-    const feedbackTimerRef = useRef(null);
-    useEffect(() => {
-        return () => {
-            if (feedbackTimerRef.current)
-                clearTimeout(feedbackTimerRef.current);
-        };
-    }, []);
-    const handlePublish = useCallback(async () => {
-        if (!siteConfig)
-            return;
-        setIsPublishing(true);
-        setPublishFeedback(null);
-        try {
-            cancelPendingFlush();
-            await flushNow();
-            const hasChanges = await hasLocalChanges();
-            const hasMediaChanges = pendingMediaItems.length > 0 || pendingMediaDeletions.length > 0;
-            if (!hasChanges && !isConfigDirty() && !hasMediaChanges) {
-                setIsPublishing(false);
-                return;
-            }
-            const dirty = await getDirtySections();
-            // Gather pending media for the commit
-            const mediaUploads = [];
-            const blobUrlsToRevoke = [];
-            for (const item of pendingMediaItems) {
-                const localUrls = await getPendingMediaLocalUrls(item.id);
-                if (!localUrls)
-                    continue;
-                for (const url of Object.values(localUrls)) {
-                    blobUrlsToRevoke.push(url);
-                }
-                const blobs = [];
-                const failedBlobFetches = [];
-                const mimeExt = {
-                    "image/gif": "gif", "image/apng": "apng", "video/mp4": "mp4", "video/webm": "webm",
-                };
-                for (const [key, url] of Object.entries(localUrls)) {
-                    if (key === "primary" && item.kind === "image")
-                        continue;
-                    try {
-                        const resp = await fetch(url);
-                        const blob = await resp.blob();
-                        const base64 = await blobToBase64(blob);
-                        if (key === "primary") {
-                            const ext = mimeExt[item.mimeType] ?? "bin";
-                            blobs.push({ path: `assets/images/${item.folder}/original.${ext}`, base64 });
-                        }
-                        else {
-                            blobs.push({ path: `assets/images/${item.folder}/${key}.webp`, base64 });
-                        }
-                    }
-                    catch {
-                        failedBlobFetches.push(`${item.id}/${key}`);
-                    }
-                }
-                if (failedBlobFetches.length > 0) {
-                    throw new Error(`Media upload failed: could not read blob data for ${failedBlobFetches.join(", ")}`);
-                }
-                if (blobs.length > 0) {
-                    mediaUploads.push({ item, blobs });
-                }
-            }
-            // Build updated manifest
-            let updatedManifest;
-            if (hasMediaChanges) {
-                const images = { ...mediaManifest.images };
-                for (const upload of mediaUploads) {
-                    images[upload.item.id] = upload.item;
-                }
-                for (const id of pendingMediaDeletions) {
-                    delete images[id];
-                }
-                updatedManifest = { images };
-            }
-            const response = await fetch("/api/save", {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    sections: dirty.map(({ sectionId, content }) => ({
-                        id: sectionId,
-                        content,
-                    })),
-                    siteIndex: siteIndexRef.current,
-                    ...(isConfigDirty() ? { siteConfig } : {}),
-                    ...(hasMediaChanges ? {
-                        media: {
-                            uploads: mediaUploads.map(({ item, blobs }) => ({ item, blobs })),
-                            deletions: pendingMediaDeletions.map((id) => ({
-                                id,
-                                folder: mediaManifest.images[id]?.folder,
-                            })).filter((d) => d.folder),
-                            manifest: updatedManifest,
-                        },
-                    } : {}),
-                }),
-            });
-            if (!response.ok) {
-                const errorBody = await response.json().catch(() => ({}));
-                throw new Error(errorBody.error || "Publish failed");
-            }
-            const { sha } = await response.json();
-            await discardLocalChanges();
-            await clearPendingMedia();
-            await cacheContent(sha, sections, siteIndexRef.current, siteConfig);
-            clearConfigDirty();
-            onSuccess();
-            onMediaPublished(pendingMediaItems, pendingMediaDeletions);
-            for (const url of blobUrlsToRevoke) {
-                URL.revokeObjectURL(url);
-            }
-            setPublishFeedback("Published");
-            if (feedbackTimerRef.current)
-                clearTimeout(feedbackTimerRef.current);
-            feedbackTimerRef.current = setTimeout(() => setPublishFeedback(null), 3000);
-        }
-        catch (error) {
-            console.error("Publish failed:", error);
-            setPublishFeedback("Publish failed");
-            if (feedbackTimerRef.current)
-                clearTimeout(feedbackTimerRef.current);
-            feedbackTimerRef.current = setTimeout(() => setPublishFeedback(null), 5000);
-        }
-        finally {
-            setIsPublishing(false);
-        }
-    }, [flushNow, cancelPendingFlush, isConfigDirty, clearConfigDirty, siteIndexRef, siteConfig, sections, onSuccess, mediaManifest, pendingMediaItems, pendingMediaDeletions, onMediaPublished]);
-    return { isPublishing, publishFeedback, handlePublish };
-}

package/dist/hooks/useFocusTrap.js

@@ -1,51 +0,0 @@
-import { useEffect } from "react";
-const FOCUSABLE_SELECTOR = [
-    "a[href]",
-    "button:not([disabled])",
-    "input:not([disabled])",
-    "select:not([disabled])",
-    "textarea:not([disabled])",
-    '[tabindex]:not([tabindex="-1"])',
-].join(", ");
-export function useFocusTrap(ref, active) {
-    useEffect(() => {
-        if (!active || !ref.current)
-            return;
-        const container = ref.current;
-        const previouslyFocused = document.activeElement;
-        const getFocusable = () => Array.from(container.querySelectorAll(FOCUSABLE_SELECTOR));
-        // Focus first element on activation
-        const focusable = getFocusable();
-        if (focusable.length > 0) {
-            focusable[0].focus();
-        }
-        const handleKeyDown = (e) => {
-            if (e.key !== "Tab")
-                return;
-            const elements = getFocusable();
-            if (elements.length === 0)
-                return;
-            const first = elements[0];
-            const last = elements[elements.length - 1];
-            if (e.shiftKey) {
-                if (document.activeElement === first) {
-                    e.preventDefault();
-                    last.focus();
-                }
-            }
-            else {
-                if (document.activeElement === last) {
-                    e.preventDefault();
-                    first.focus();
-                }
-            }
-        };
-        container.addEventListener("keydown", handleKeyDown);
-        return () => {
-            container.removeEventListener("keydown", handleKeyDown);
-            if (previouslyFocused && document.body.contains(previouslyFocused)) {
-                previouslyFocused.focus();
-            }
-        };
-    }, [active, ref]);
-}

package/dist/hooks/useMediaPipeline.js

@@ -1,253 +0,0 @@
-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.js

@@ -1,39 +0,0 @@
-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/lib/cn.js

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