@drawnagency/primitives 0.1.0

package/dist/hooks/index.d.ts

@@ -0,0 +1,7 @@
+export { useActiveHeadings } from "./useActiveHeadings";
+export { useEditorPersistence } from "./useEditorPersistence";
+export { useEditorPublish } from "./useEditorPublish";
+export { useFocusTrap } from "./useFocusTrap";
+export { useMediaPipeline } from "./useMediaPipeline";
+export { useResolvedMedia } from "./useResolvedMedia";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/hooks/index.js

@@ -0,0 +1,6 @@
+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.d.ts

@@ -0,0 +1,7 @@
+export declare function useActiveHeadings(parentIds: string[], childIdsByParent: Record<string, string[]>, grandchildIdsByChild: Record<string, string[]>, headerOffset?: number): {
+    activeParentId: string;
+    activeChildId: string;
+    activeGrandchildId: string;
+    setActiveSection: (id: string) => void;
+};
+//# sourceMappingURL=useActiveHeadings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useActiveHeadings.d.ts","sourceRoot":"","sources":["../../src/hooks/useActiveHeadings.ts"],"names":[],"mappings":"AAEA,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EAAE,EACnB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAC1C,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAC9C,YAAY,GAAE,MAAW;;;;2BAyGiB,MAAM;EAQjD"}

package/dist/hooks/useActiveHeadings.js

@@ -0,0 +1,99 @@
+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.d.ts

@@ -0,0 +1,13 @@
+import type { SectionContent } from "../schemas/sections";
+import type { SiteIndex } from "../schemas/site-config";
+export declare function useEditorPersistence(siteIndexRef: React.RefObject<SiteIndex>): {
+    markSectionDirty: (sectionId: string, content: SectionContent) => void;
+    markSectionDeleted: (sectionId: string) => void;
+    markIndexDirty: () => void;
+    persistConfig: (config: Record<string, unknown>) => Promise<void>;
+    flushNow: () => Promise<void>;
+    cancelPendingFlush: () => void;
+    isConfigDirty: () => boolean;
+    clearConfigDirty: () => void;
+};
+//# sourceMappingURL=useEditorPersistence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useEditorPersistence.d.ts","sourceRoot":"","sources":["../../src/hooks/useEditorPersistence.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAUxD,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,SAAS,CAAC;kCA2C7D,MAAM,WAAW,cAAc;oCAQ/B,MAAM;;4BAc6B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;EAyBzE"}

package/dist/hooks/useEditorPersistence.js

@@ -0,0 +1,73 @@
+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.d.ts

@@ -0,0 +1,24 @@
+import type { SiteIndex, SiteConfig } from "../schemas/site-config";
+import type { LoadedSection } from "../lib/loader";
+import type { MediaManifest, MediaItem } from "../media/types";
+interface PublishDeps {
+    flushNow: () => Promise<void>;
+    cancelPendingFlush: () => void;
+    isConfigDirty: () => boolean;
+    clearConfigDirty: () => void;
+    siteIndexRef: React.RefObject<SiteIndex>;
+    siteConfig: SiteConfig | null;
+    sections: LoadedSection[];
+    onSuccess: () => void;
+    mediaManifest: MediaManifest;
+    pendingMediaItems: MediaItem[];
+    pendingMediaDeletions: string[];
+    onMediaPublished: (publishedItems: MediaItem[], publishedDeletions: string[]) => void;
+}
+export declare function useEditorPublish({ flushNow, cancelPendingFlush, isConfigDirty, clearConfigDirty, siteIndexRef, siteConfig, sections, onSuccess, mediaManifest, pendingMediaItems, pendingMediaDeletions, onMediaPublished, }: PublishDeps): {
+    isPublishing: boolean;
+    publishFeedback: string | null;
+    handlePublish: () => Promise<void>;
+};
+export {};
+//# sourceMappingURL=useEditorPublish.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useEditorPublish.d.ts","sourceRoot":"","sources":["../../src/hooks/useEditorPublish.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAe/D,UAAU,WAAW;IACnB,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,kBAAkB,EAAE,MAAM,IAAI,CAAC;IAC/B,aAAa,EAAE,MAAM,OAAO,CAAC;IAC7B,gBAAgB,EAAE,MAAM,IAAI,CAAC;IAC7B,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IACzC,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,aAAa,EAAE,aAAa,CAAC;IAC7B,iBAAiB,EAAE,SAAS,EAAE,CAAC;IAC/B,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,gBAAgB,EAAE,CAAC,cAAc,EAAE,SAAS,EAAE,EAAE,kBAAkB,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CACvF;AAED,wBAAgB,gBAAgB,CAAC,EAC/B,QAAQ,EACR,kBAAkB,EAClB,aAAa,EACb,gBAAgB,EAChB,YAAY,EACZ,UAAU,EACV,QAAQ,EACR,SAAS,EACT,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,GACjB,EAAE,WAAW;;;;EA4Ib"}

package/dist/hooks/useEditorPublish.js

@@ -0,0 +1,145 @@
+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.d.ts

@@ -0,0 +1,3 @@
+import { type RefObject } from "react";
+export declare function useFocusTrap(ref: RefObject<HTMLElement | null>, active: boolean): void;
+//# sourceMappingURL=useFocusTrap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useFocusTrap.d.ts","sourceRoot":"","sources":["../../src/hooks/useFocusTrap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAWlD,wBAAgB,YAAY,CAAC,GAAG,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,QA6C/E"}

package/dist/hooks/useFocusTrap.js

@@ -0,0 +1,51 @@
+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.d.ts

@@ -0,0 +1,65 @@
+import { type QueueItem } from "../media/queue";
+import type { MediaManifest } from "../media/types";
+import type { SiteConfig } from "../schemas/site-config";
+import type { SectionContent } from "../schemas/sections";
+import type { LoadedSection } from "../lib/loader";
+import type { MediaLibraryContextValue } from "../components/shell/MediaLibraryContext";
+interface UseMediaPipelineInput {
+    siteConfig: SiteConfig | null;
+    mediaManifest: MediaManifest;
+    setMediaManifest: React.Dispatch<React.SetStateAction<MediaManifest>>;
+    sections: LoadedSection[];
+    setSections: React.Dispatch<React.SetStateAction<LoadedSection[]>>;
+    setLocalChangesExist: React.Dispatch<React.SetStateAction<boolean>>;
+    setDirtySectionIds: React.Dispatch<React.SetStateAction<Set<string>>>;
+    markSectionDirty: (sectionId: string, content: SectionContent) => void;
+}
+export declare function useMediaPipeline({ siteConfig, mediaManifest, setMediaManifest, sections, setSections, setLocalChangesExist, setDirtySectionIds, markSectionDirty, }: UseMediaPipelineInput): {
+    processingItems: QueueItem[];
+    pendingMediaItems: {
+        id: string;
+        hash: string;
+        kind: "image" | "video" | "animated";
+        originalName: string;
+        width: number;
+        height: number;
+        mimeType: string;
+        size: number;
+        folder: string;
+        variants: {
+            width: number;
+            height: number;
+            size: number;
+        }[];
+        alt: string;
+    }[];
+    setPendingMediaItems: import("react").Dispatch<import("react").SetStateAction<{
+        id: string;
+        hash: string;
+        kind: "image" | "video" | "animated";
+        originalName: string;
+        width: number;
+        height: number;
+        mimeType: string;
+        size: number;
+        folder: string;
+        variants: {
+            width: number;
+            height: number;
+            size: number;
+        }[];
+        alt: string;
+    }[]>>;
+    pendingLocalUrls: Record<string, string>;
+    setPendingLocalUrls: import("react").Dispatch<import("react").SetStateAction<Record<string, string>>>;
+    pendingDeletions: string[];
+    setPendingDeletions: import("react").Dispatch<import("react").SetStateAction<string[]>>;
+    handleMediaUpload: (files: File[]) => Promise<void>;
+    handleMediaDelete: (ids: string[]) => Promise<void>;
+    handleMediaAltChange: (id: string, alt: string) => void;
+    referenceCountMap: Record<string, number>;
+    contextValue: MediaLibraryContextValue;
+    enqueueFile: (file: File, onComplete?: (imageId: string) => void) => void;
+};
+export {};
+//# sourceMappingURL=useMediaPipeline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMediaPipeline.d.ts","sourceRoot":"","sources":["../../src/hooks/useMediaPipeline.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,KAAK,SAAS,EAAmB,MAAM,gBAAgB,CAAC;AAClF,OAAO,KAAK,EAAE,aAAa,EAAiC,MAAM,gBAAgB,CAAC;AACnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AAwBxF,UAAU,qBAAqB;IAC7B,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B,aAAa,EAAE,aAAa,CAAC;IAC7B,gBAAgB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC;IACtE,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;IACnE,oBAAoB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;IACpE,kBAAkB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACtE,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;CACxE;AAED,wBAAgB,gBAAgB,CAAC,EAC/B,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,QAAQ,EACR,WAAW,EACX,oBAAoB,EACpB,kBAAkB,EAClB,gBAAgB,GACjB,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BA8G8B,IAAI,EAAE;6BAwBR,MAAM,EAAE;+BAuBZ,MAAM,OAAO,MAAM;;;wBA+B1B,IAAI,eAAe,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;EAqEpF"}