@jhits/plugin-images 0.0.12 → 0.0.14

package/dist/api/list/index.d.ts

@@ -4,6 +4,17 @@
  */
 import { NextRequest, NextResponse } from 'next/server';
 export declare function GET(request: NextRequest): Promise<NextResponse<{
+    images: never[];
+    total: number;
+    page: number;
+    limit: number;
+    stats: {
+        totalImages: number;
+        totalSize: number;
+        usedImages: number;
+        availableImages: number;
+    };
+}> | NextResponse<{
     images: {
         id: string;
         filename: string;
@@ -15,6 +26,13 @@ export declare function GET(request: NextRequest): Promise<NextResponse<{
     total: number;
     page: number;
     limit: number;
+    stats: {
+        totalImages: number;
+        totalSize: number;
+        usedImages: number;
+        availableImages: number;
+    };
+    mappedImages: string[];
 }> | NextResponse<{
     error: string;
 }>>;

package/dist/api/list/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/list/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAMxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;IAmF7C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/list/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAiGxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqH7C"}

package/dist/api/list/index.js

@@ -6,52 +6,146 @@ import { NextResponse } from 'next/server';
 import { readdir, stat } from 'fs/promises';
 import path from 'path';
 const uploadsDir = path.join(process.cwd(), 'data', 'uploads');
+const mappingsPath = path.join(process.cwd(), 'data', 'image-mappings.json');
+async function queryDatabase() {
+    const blogFilenames = new Set();
+    const userFilenames = new Set();
+    try {
+        const { MongoClient } = await import('mongodb');
+        const uri = process.env.DATABASE_URL || process.env.MONGODB_URI;
+        if (!uri)
+            return { blogFilenames, userFilenames };
+        const client = new MongoClient(uri);
+        await client.connect();
+        const db = client.db();
+        // Get blogs
+        const blogs = await db.collection('blogs').find({}).project({ image: 1, contentBlocks: 1 }).toArray();
+        for (const blog of blogs) {
+            // Featured image
+            if (blog.image?.id)
+                blogFilenames.add(blog.image.id);
+            if (blog.image?.src)
+                blogFilenames.add(blog.image.src);
+            // Content blocks - recursively find image.src
+            if (blog.contentBlocks) {
+                const findImages = (obj) => {
+                    if (!obj || typeof obj !== 'object')
+                        return;
+                    if (Array.isArray(obj)) {
+                        obj.forEach(findImages);
+                        return;
+                    }
+                    if (obj.src && typeof obj.src === 'string' && !obj.src.startsWith('http')) {
+                        blogFilenames.add(obj.src);
+                    }
+                    if (obj.children)
+                        findImages(obj.children);
+                    if (obj.data)
+                        findImages(obj.data);
+                };
+                findImages(blog.contentBlocks);
+            }
+        }
+        // Get users with avatars
+        const users = await db.collection('users').find({ image: { $exists: true, $ne: null } }).project({ image: 1 }).toArray();
+        for (const user of users) {
+            if (user.image && user.image.includes('/api/uploads/')) {
+                const filename = user.image.split('/api/uploads/')[1];
+                if (filename)
+                    userFilenames.add(filename);
+            }
+        }
+        await client.close();
+    }
+    catch (error) {
+        console.error('Error querying database for list:', error);
+    }
+    return { blogFilenames, userFilenames };
+}
+function extractMappings() {
+    const mappedFilenames = new Set();
+    const semanticIdToFilename = {};
+    try {
+        const mappingsContent = require('fs').readFileSync(mappingsPath, 'utf-8');
+        const mappings = JSON.parse(mappingsContent);
+        Object.entries(mappings).forEach(([semanticId, mapping]) => {
+            const filename = typeof mapping === 'string' ? mapping : mapping.filename;
+            if (filename) {
+                mappedFilenames.add(filename);
+                semanticIdToFilename[semanticId] = filename;
+            }
+        });
+    }
+    catch { }
+    return { mappedFilenames, semanticIdToFilename };
+}
 export async function GET(request) {
     try {
         const { searchParams } = new URL(request.url);
         const page = parseInt(searchParams.get('page') || '1');
-        const limit = parseInt(searchParams.get('limit') || '20');
+        const limit = parseInt(searchParams.get('limit') || '1000');
         const search = searchParams.get('search') || '';
-        // Read uploads directory
         let files = [];
+        let totalSize = 0;
         try {
             files = await readdir(uploadsDir);
         }
         catch (error) {
-            // Directory doesn't exist yet
             return NextResponse.json({
                 images: [],
                 total: 0,
                 page: 1,
                 limit,
+                stats: {
+                    totalImages: 0,
+                    totalSize: 0,
+                    usedImages: 0,
+                    availableImages: 0,
+                }
             });
         }
-        // Filter image files and get metadata
         const imageExtensions = ['.jpg', '.jpeg', '.png', '.webp', '.gif'];
         const imageFiles = files.filter(file => {
             const ext = path.extname(file).toLowerCase();
             return imageExtensions.includes(ext);
         });
-        // Apply search filter if provided
-        const filteredFiles = search
-            ? imageFiles.filter(file => file.toLowerCase().includes(search.toLowerCase()))
-            : imageFiles;
-        // Sort by modification time (newest first)
-        const filesWithStats = await Promise.all(filteredFiles.map(async (filename) => {
+        const filesWithStats = await Promise.all(imageFiles.map(async (filename) => {
             const filePath = path.join(uploadsDir, filename);
-            const stats = await stat(filePath);
-            return {
-                filename,
-                mtime: stats.mtime,
-                size: stats.size,
-            };
+            try {
+                const stats = await stat(filePath);
+                totalSize += stats.size;
+                return {
+                    filename,
+                    mtime: stats.mtime,
+                    size: stats.size,
+                };
+            }
+            catch {
+                return { filename, mtime: new Date(), size: 0 };
+            }
         }));
-        filesWithStats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-        // Paginate
+        // Get mappings
+        const { mappedFilenames, semanticIdToFilename } = extractMappings();
+        // Get database references
+        const { blogFilenames, userFilenames } = await queryDatabase();
+        // An image is "in use" if it's in mappings OR referenced in database
+        // First resolve database references through mappings, then check
+        const inUseFilenames = new Set();
+        // Add mapped filenames
+        mappedFilenames.forEach(f => inUseFilenames.add(f));
+        // Add database references (check if they resolve through mappings)
+        [...blogFilenames, ...userFilenames].forEach(idOrFilename => {
+            const resolved = semanticIdToFilename[idOrFilename] || idOrFilename;
+            inUseFilenames.add(resolved);
+        });
+        const usedCount = filesWithStats.filter(f => inUseFilenames.has(f.filename)).length;
+        const filteredFiles = search
+            ? filesWithStats.filter(file => file.filename.toLowerCase().includes(search.toLowerCase()))
+            : filesWithStats;
+        filteredFiles.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
         const start = (page - 1) * limit;
         const end = start + limit;
-        const paginatedFiles = filesWithStats.slice(start, end);
-        // Build image metadata
+        const paginatedFiles = filteredFiles.slice(start, end);
         const images = paginatedFiles.map(({ filename, mtime, size }) => {
             const ext = path.extname(filename).toLowerCase();
             const mimeType = ext === '.png' ? 'image/png' :
@@ -71,6 +165,13 @@ export async function GET(request) {
             total: filteredFiles.length,
             page,
             limit,
+            stats: {
+                totalImages: imageFiles.length,
+                totalSize,
+                usedImages: usedCount,
+                availableImages: imageFiles.length - usedCount,
+            },
+            mappedImages: Array.from(mappedFilenames),
         });
     }
     catch (error) {

package/dist/api/router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/api/router.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAExD;;;GAGG;AACH,wBAAsB,eAAe,CACjC,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,EAAE,GACf,OAAO,CAAC,YAAY,CAAC,CAgEvB"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/api/router.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAExD;;;GAGG;AACH,wBAAsB,eAAe,CACjC,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,EAAE,GACf,OAAO,CAAC,YAAY,CAAC,CAwEvB"}

package/dist/api/router.js

@@ -57,6 +57,13 @@ export async function handleImagesApi(req, path) {
                 return await fallbackModule.GET(req);
             }
         }
+        // Route: /api/plugin-images/usage (get image usage across plugins)
+        else if (route === 'usage') {
+            if (method === 'GET') {
+                const usageModule = await import('./usage/route');
+                return await usageModule.GET(req);
+            }
+        }
         // Method not allowed
         return NextResponse.json({ error: `Method ${method} not allowed for route: ${route || '/'}` }, { status: 405 });
     }

package/dist/api/usage/route.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Image Usage API Handler
+ * GET /api/plugin-images/usage - Returns usage information for all images
+ */
+import { NextRequest, NextResponse } from 'next/server';
+interface ImageUsage {
+    imageId: string;
+    filename: string;
+    usage: Array<{
+        plugin: string;
+        type: string;
+        title: string;
+        id: string;
+        url?: string;
+    }>;
+}
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    images: ImageUsage[];
+}> | NextResponse<{
+    error: string;
+}>>;
+export {};
+//# sourceMappingURL=route.d.ts.map

package/dist/api/usage/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../src/api/usage/route.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAOxD,UAAU,UAAU;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;QACT,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,EAAE,EAAE,MAAM,CAAC;QACX,GAAG,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;CACN;AAsID,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;IAyI7C"}

package/dist/api/usage/route.js

@@ -0,0 +1,238 @@
+/**
+ * Image Usage API Handler
+ * GET /api/plugin-images/usage - Returns usage information for all images
+ */
+import { NextResponse } from 'next/server';
+import { readdir, readFile } from 'fs/promises';
+import path from 'path';
+const uploadsDir = path.join(process.cwd(), 'data', 'uploads');
+const mappingsPath = path.join(process.cwd(), 'data', 'image-mappings.json');
+async function getMappings() {
+    try {
+        const content = await readFile(mappingsPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+async function queryMongoDatabase() {
+    try {
+        const { MongoClient } = await import('mongodb');
+        const uri = process.env.DATABASE_URL || process.env.MONGODB_URI;
+        if (!uri) {
+            return { blogs: [], newsletters: [], users: [] };
+        }
+        const client = new MongoClient(uri);
+        await client.connect();
+        const db = client.db();
+        const blogsRaw = await db.collection('blogs')
+            .find({}, { projection: { slug: 1, title: 1, image: 1, contentBlocks: 1 } })
+            .toArray();
+        const blogs = blogsRaw.map(doc => ({
+            _id: doc._id?.toString() || '',
+            slug: doc.slug || '',
+            title: doc.title || '',
+            image: doc.image || {},
+            contentBlocks: doc.contentBlocks || [],
+        }));
+        const newslettersRaw = await db.collection('newsletters')
+            .find({}, { projection: { slug: 1, title: 1, content: 1 } })
+            .toArray();
+        const newsletters = newslettersRaw.map(doc => ({
+            _id: doc._id?.toString() || '',
+            slug: doc.slug || '',
+            title: doc.title || '',
+            content: doc.content || [],
+        }));
+        // Get users with avatars
+        const usersRaw = await db.collection('users')
+            .find({ image: { $exists: true, $ne: null } })
+            .project({ name: 1, email: 1, image: 1 })
+            .toArray();
+        const users = usersRaw.map(doc => ({
+            _id: doc._id?.toString() || '',
+            name: doc.name || '',
+            email: doc.email || '',
+            image: doc.image || '',
+        }));
+        await client.close();
+        return { blogs, newsletters, users };
+    }
+    catch (error) {
+        console.error('Error querying MongoDB:', error);
+        return { blogs: [], newsletters: [], users: [] };
+    }
+}
+function extractImageFilenamesFromContentBlocks(blocks) {
+    const imageFilenames = new Set();
+    function traverse(obj) {
+        if (!obj || typeof obj !== 'object')
+            return;
+        if (Array.isArray(obj)) {
+            obj.forEach(item => traverse(item));
+            return;
+        }
+        // Check for image object with src or id
+        if (obj.src) {
+            const filename = obj.src;
+            if (filename && !filename.startsWith('http') && !filename.startsWith('data:')) {
+                imageFilenames.add(filename);
+            }
+        }
+        // Check for imageId (used by BotanicsAndYou Image block)
+        if (obj.imageId && typeof obj.imageId === 'string' && !obj.imageId.startsWith('http')) {
+            imageFilenames.add(obj.imageId);
+        }
+        if (obj.id && typeof obj.id === 'string' && !obj.id.startsWith('http') && !obj.id.startsWith('block-')) {
+            // This might be an image ID - but be careful not to catch block IDs
+            const ext = path.extname(obj.id);
+            if (ext && ['.jpg', '.jpeg', '.png', '.webp', '.gif', '.svg'].includes(ext.toLowerCase())) {
+                imageFilenames.add(obj.id);
+            }
+        }
+        // Check children
+        if (obj.children && Array.isArray(obj.children)) {
+            obj.children.forEach((child) => traverse(child));
+        }
+        // Check data
+        if (obj.data && typeof obj.data === 'object') {
+            traverse(obj.data);
+        }
+    }
+    blocks.forEach(block => traverse(block));
+    return Array.from(imageFilenames);
+}
+function extractImageIdsFromContent(content) {
+    const imageIds = new Set();
+    if (!content || !Array.isArray(content)) {
+        return [];
+    }
+    for (const block of content) {
+        if (block.type === 'image' && block.data?.imageId) {
+            imageIds.add(block.data.imageId);
+        }
+    }
+    return Array.from(imageIds);
+}
+export async function GET(request) {
+    try {
+        const { searchParams } = new URL(request.url);
+        const filename = searchParams.get('filename');
+        let files = [];
+        try {
+            files = await readdir(uploadsDir);
+        }
+        catch {
+            return NextResponse.json({ images: [] });
+        }
+        const imageExtensions = ['.jpg', '.jpeg', '.png', '.webp', '.gif'];
+        const imageFiles = files.filter(file => {
+            const ext = path.extname(file).toLowerCase();
+            return imageExtensions.includes(ext);
+        });
+        const mappings = await getMappings();
+        const semanticIdToFilename = {};
+        Object.entries(mappings).forEach(([semanticId, mapping]) => {
+            const mappedFilename = typeof mapping === 'string' ? mapping : mapping.filename;
+            if (mappedFilename) {
+                semanticIdToFilename[semanticId] = mappedFilename;
+            }
+        });
+        const { blogs, newsletters, users } = await queryMongoDatabase();
+        const images = imageFiles.map((file) => {
+            const usage = [];
+            blogs.forEach((blog) => {
+                const imageFilenamesInBlog = new Set();
+                // 1. Featured image at root level (blog.image.id or blog.image.src)
+                const featuredImage = blog.image;
+                if (featuredImage) {
+                    const featuredId = featuredImage.id || featuredImage.src;
+                    if (featuredId) {
+                        const resolved = semanticIdToFilename[featuredId] || featuredId;
+                        imageFilenamesInBlog.add(resolved);
+                        // Check if this file matches
+                        if (resolved === file || resolved === path.basename(file, path.extname(file))) {
+                            usage.push({
+                                plugin: 'blog',
+                                type: 'featured-image',
+                                title: blog.title || blog.slug || 'Untitled',
+                                id: blog.slug || blog._id,
+                                url: `/dashboard/blog/editor/${blog.slug || blog._id}`,
+                            });
+                        }
+                    }
+                }
+                // 2. Images in contentBlocks
+                const contentBlockImages = extractImageFilenamesFromContentBlocks(blog.contentBlocks || []);
+                contentBlockImages.forEach(imgId => {
+                    const resolved = semanticIdToFilename[imgId] || imgId;
+                    imageFilenamesInBlog.add(resolved);
+                    if (resolved === file || resolved === path.basename(file, path.extname(file))) {
+                        // Avoid duplicate entries for the same blog
+                        const existing = usage.find(u => u.id === (blog.slug || blog._id) && u.plugin === 'blog');
+                        if (!existing) {
+                            usage.push({
+                                plugin: 'blog',
+                                type: 'content-image',
+                                title: blog.title || blog.slug || 'Untitled',
+                                id: blog.slug || blog._id,
+                                url: `/dashboard/blog/editor/${blog.slug || blog._id}`,
+                            });
+                        }
+                    }
+                });
+            });
+            newsletters.forEach((newsletter) => {
+                const imageIds = extractImageIdsFromContent(newsletter.content || []);
+                imageIds.forEach(imageId => {
+                    const resolvedFilename = semanticIdToFilename[imageId] || imageId;
+                    if (resolvedFilename === file || resolvedFilename === path.basename(file, path.extname(file))) {
+                        const existing = usage.find(u => u.id === (newsletter.slug || newsletter._id) && u.plugin === 'newsletter');
+                        if (!existing) {
+                            usage.push({
+                                plugin: 'newsletter',
+                                type: 'image-block',
+                                title: newsletter.title || newsletter.slug || 'Untitled',
+                                id: newsletter.slug || newsletter._id,
+                                url: `/dashboard/newsletter/editor/${newsletter.slug || newsletter._id}`,
+                            });
+                        }
+                    }
+                });
+            });
+            // Check user avatars
+            users.forEach((user) => {
+                if (user.image && user.image.includes('/api/uploads/')) {
+                    const avatarFilename = user.image.split('/api/uploads/')[1];
+                    if (avatarFilename && (avatarFilename === file || avatarFilename === path.basename(file, path.extname(file)))) {
+                        const existing = usage.find(u => u.id === user._id && u.plugin === 'users');
+                        if (!existing) {
+                            usage.push({
+                                plugin: 'users',
+                                type: 'avatar',
+                                title: user.name || user.email || 'Unknown User',
+                                id: user._id,
+                                url: `/dashboard/users`,
+                            });
+                        }
+                    }
+                }
+            });
+            return {
+                imageId: file,
+                filename: file,
+                usage,
+            };
+        });
+        if (filename) {
+            const filtered = images.filter(img => img.filename === filename || img.imageId === filename);
+            return NextResponse.json({ images: filtered });
+        }
+        return NextResponse.json({ images });
+    }
+    catch (error) {
+        console.error('Get image usage error:', error);
+        return NextResponse.json({ error: 'Failed to get image usage' }, { status: 500 });
+    }
+}

package/dist/components/BackgroundImage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BackgroundImage.d.ts","sourceRoot":"","sources":["../../src/components/BackgroundImage.tsx"],"names":[],"mappings":"AAEA,OAAO,KAA8B,MAAM,OAAO,CAAC;AAInD,MAAM,WAAW,oBAAoB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAC5B,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,cAAc,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;IACvD,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,wBAAgB,eAAe,CAAC,EAC5B,EAAE,EACF,SAAc,EACd,KAAU,EACV,QAAQ,EACR,cAAwB,EACxB,kBAA6B,GAChC,EAAE,oBAAoB,2CAqEtB"}
+{"version":3,"file":"BackgroundImage.d.ts","sourceRoot":"","sources":["../../src/components/BackgroundImage.tsx"],"names":[],"mappings":"AAEA,OAAO,KAA8B,MAAM,OAAO,CAAC;AAInD,MAAM,WAAW,oBAAoB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAC5B,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,cAAc,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;IACvD,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,wBAAgB,eAAe,CAAC,EAC5B,EAAE,EACF,SAAc,EACd,KAAU,EACV,QAAQ,EACR,cAAwB,EACxB,kBAA6B,GAChC,EAAE,oBAAoB,2CA2DtB"}

package/dist/components/BackgroundImage.js

@@ -1,28 +1,16 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useEffect } from 'react';
-import { Image } from './Image';
+import { Image, checkAuthOnce } from './Image';
 import { Edit2 } from 'lucide-react';
 export function BackgroundImage({ id, className = '', style = {}, children, backgroundSize = 'cover', backgroundPosition = 'center', }) {
     const [isAdmin, setIsAdmin] = useState(false);
     const [isLoading, setIsLoading] = useState(true);
     useEffect(() => {
-        const checkUser = async () => {
-            try {
-                const res = await fetch('/api/me');
-                const data = await res.json();
-                if (data.loggedIn && ['admin', 'dev'].includes(data.user?.role)) {
-                    setIsAdmin(true);
-                }
-            }
-            catch (error) {
-                console.error('Auth error:', error);
-            }
-            finally {
-                setIsLoading(false);
-            }
-        };
-        checkUser();
+        checkAuthOnce().then(isAuth => {
+            setIsAdmin(isAuth);
+            setIsLoading(false);
+        });
     }, []);
     const handleEditClick = (e) => {
         e.preventDefault();

package/dist/components/GlobalImageEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GlobalImageEditor.d.ts","sourceRoot":"","sources":["../../src/components/GlobalImageEditor.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAeH,wBAAgB,iBAAiB,mDAkThC"}
+{"version":3,"file":"GlobalImageEditor.d.ts","sourceRoot":"","sources":["../../src/components/GlobalImageEditor.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAgBH,wBAAgB,iBAAiB,mDAsThC"}

package/dist/components/GlobalImageEditor.js

@@ -14,6 +14,7 @@ import { parseImageData } from './GlobalImageEditor/imageDetection';
 import { setupImageHandlers } from './GlobalImageEditor/imageSetup';
 import { saveTransformToAPI, flushPendingSave, getFilename, normalizePosition } from './GlobalImageEditor/saveLogic';
 import { handleImageChange, handleBrightnessChange, handleBlurChange } from './GlobalImageEditor/eventHandlers';
+import { checkAuthOnce } from './Image';
 export function GlobalImageEditor() {
     // Configuration
     const config = useMemo(() => getPluginConfig(), []);
@@ -29,10 +30,14 @@ export function GlobalImageEditor() {
     useEffect(() => {
         const checkUser = async () => {
             try {
-                const res = await fetch('/api/me');
-                const data = await res.json();
-                if (data.loggedIn && (data.user?.role === 'admin' || data.user?.role === 'dev')) {
-                    setUserRole(data.user.role);
+                const isAuth = await checkAuthOnce();
+                if (isAuth) {
+                    // Need to fetch again to get user role since checkAuthOnce only returns boolean
+                    const res = await fetch('/api/me');
+                    const data = await res.json();
+                    if (data.user?.role === 'admin' || data.user?.role === 'dev') {
+                        setUserRole(data.user.role);
+                    }
                 }
             }
             catch (error) {

package/dist/components/Image.d.ts

@@ -1,4 +1,6 @@
 import React from 'react';
+export declare let authCache: boolean | null;
+export declare function checkAuthOnce(): Promise<boolean>;
 export interface PluginImageProps {
     id: string;
     alt: string;

package/dist/components/Image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Image.d.ts","sourceRoot":"","sources":["../../src/components/Image.tsx"],"names":[],"mappings":"AAGA,OAAO,KAA4D,MAAM,OAAO,CAAC;AAKjF,MAAM,WAAW,gBAAgB;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,YAAY,CAAC;IACjE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAC5B,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,KAAK,CAAC,EAClB,EAAE,EACF,GAAG,EACH,KAAK,EACL,MAAM,EACN,SAAc,EACd,IAAY,EACZ,KAAK,EACL,QAAgB,EAChB,SAAmB,EACnB,cAAyB,EACzB,KAAK,EACL,QAAe,EACf,GAAG,KAAK,EACX,EAAE,gBAAgB,2CA2SlB"}
+{"version":3,"file":"Image.d.ts","sourceRoot":"","sources":["../../src/components/Image.tsx"],"names":[],"mappings":"AAGA,OAAO,KAA4D,MAAM,OAAO,CAAC;AAKjF,eAAO,IAAI,SAAS,EAAE,OAAO,GAAG,IAAW,CAAC;AAG5C,wBAAsB,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC,CAiBtD;AAED,MAAM,WAAW,gBAAgB;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,YAAY,CAAC;IACjE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAC5B,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,KAAK,CAAC,EAClB,EAAE,EACF,GAAG,EACH,KAAK,EACL,MAAM,EACN,SAAc,EACd,IAAY,EACZ,KAAK,EACL,QAAgB,EAChB,SAAmB,EACnB,cAAyB,EACzB,KAAK,EACL,QAAe,EACf,GAAG,KAAK,EACX,EAAE,gBAAgB,2CAoSlB"}

package/dist/components/Image.js

@@ -5,6 +5,26 @@ import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
 import { Edit2, Loader2 } from 'lucide-react';
 import { getImageTransform, getImageFilter } from '../utils/transforms';
 import { getFallbackImageUrl } from '../utils/fallback';
+export let authCache = null;
+let authFetching = null;
+export async function checkAuthOnce() {
+    if (authCache !== null)
+        return authCache;
+    if (authFetching)
+        return authFetching;
+    authFetching = fetch('/api/me')
+        .then(res => res.json())
+        .then(data => {
+        const isAuth = data.loggedIn && ['admin', 'dev'].includes(data.user?.role);
+        authCache = isAuth;
+        return isAuth;
+    })
+        .catch(() => {
+        authCache = false;
+        return false;
+    });
+    return authFetching;
+}
 export function Image({ id, alt, width, height, className = '', fill = false, sizes, priority = false, objectFit = 'cover', objectPosition = 'center', style, editable = true, ...props // Using rest for override props
  }) {
     // 1. State management (Local only, used if props are undefined)
@@ -65,18 +85,11 @@ export function Image({ id, alt, width, height, className = '', fill = false, si
             setIsResolving(false);
         }
     }, []);
-    // 4. Auth Check (Single mount only)
+    // 4. Auth Check (Cached - only fetches once)
     useEffect(() => {
         if (!editable)
             return;
-        fetch('/api/me')
-            .then(res => res.json())
-            .then(data => {
-            if (data.loggedIn && ['admin', 'dev'].includes(data.user?.role)) {
-                setIsAuthenticated(true);
-            }
-        })
-            .catch(() => setIsAuthenticated(false));
+        checkAuthOnce().then(setIsAuthenticated);
     }, [editable]);
     // 5. Stable Event Listener (Prevents closure staleness)
     // Only fetch from API if props are not provided (parent controls the values)

package/dist/views/ImageManager.d.ts

@@ -1,6 +1,6 @@
 /**
  * Image Manager View
- * Main view for managing uploaded images
+ * Full-featured image management with CRUD operations and usage tracking
  */
 export interface ImageManagerViewProps {
     siteId: string;

package/dist/views/ImageManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageManager.d.ts","sourceRoot":"","sources":["../../src/views/ImageManager.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,WAAW,qBAAqB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,gBAAgB,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,qBAAqB,2CAczE"}
+{"version":3,"file":"ImageManager.d.ts","sourceRoot":"","sources":["../../src/views/ImageManager.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAuDH,MAAM,WAAW,qBAAqB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAClB;AAqBD,wBAAgB,gBAAgB,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,qBAAqB,2CAssBzE"}