@jhits/plugin-blog 0.0.7 → 0.0.9

package/dist/api/route.js

@@ -0,0 +1,69 @@
+/**
+ * Blog API Route Handler
+ * Server-only wrapper for the blog API handlers
+ * This file should ONLY be used in Next.js API routes
+ *
+ * IMPORTANT: This file should ONLY be imported in server-side API routes.
+ * Do NOT import this in client-side code.
+ */
+import { NextResponse } from 'next/server';
+import { GET as handlerGET, POST as handlerPOST, GET_BY_SLUG, PUT_BY_SLUG, DELETE_BY_SLUG, } from './handler';
+/**
+ * Default configuration factory
+ * Client apps should provide their own config with MongoDB connection and auth
+ */
+export function createBlogApiConfig(config) {
+    return config;
+}
+/**
+ * GET handler - List all blogs or get by slug
+ * Usage:
+ *   GET /api/blogs - List all
+ *   GET /api/blogs/[slug] - Get by slug
+ */
+export async function GET(req, context, config) {
+    if (!config) {
+        return NextResponse.json({ error: 'Blog API config not provided' }, { status: 500 });
+    }
+    // Check if we have a slug parameter (single blog request)
+    if (context?.params) {
+        const { slug } = await context.params;
+        if (slug) {
+            return GET_BY_SLUG(req, slug, config);
+        }
+    }
+    // Otherwise, list all blogs
+    return handlerGET(req, config);
+}
+/**
+ * POST handler - Create new blog
+ * Usage: POST /api/blogs
+ */
+export async function POST(req, context, config) {
+    if (!config) {
+        return NextResponse.json({ error: 'Blog API config not provided' }, { status: 500 });
+    }
+    return handlerPOST(req, config);
+}
+/**
+ * PUT handler - Update blog by slug
+ * Usage: PUT /api/blogs/[slug]
+ */
+export async function PUT(req, context, config) {
+    if (!config) {
+        return NextResponse.json({ error: 'Blog API config not provided' }, { status: 500 });
+    }
+    const { slug } = await context.params;
+    return PUT_BY_SLUG(req, slug, config);
+}
+/**
+ * DELETE handler - Delete blog by slug
+ * Usage: DELETE /api/blogs/[slug]
+ */
+export async function DELETE(req, context, config) {
+    if (!config) {
+        return NextResponse.json({ error: 'Blog API config not provided' }, { status: 500 });
+    }
+    const { slug } = await context.params;
+    return DELETE_BY_SLUG(req, slug, config);
+}

package/dist/api/router.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Plugin Blog API Router
+ * Centralized API handler for all blog plugin routes
+ *
+ * This router handles requests to /api/plugin-blog/*
+ * and routes them to the appropriate handler
+ */
+import { NextRequest, NextResponse } from 'next/server';
+export interface BlogApiRouterConfig {
+    /** MongoDB client promise - should return { db: () => Database } */
+    getDb: () => Promise<{
+        db: () => any;
+    }>;
+    /** Function to get authenticated user ID from request */
+    getUserId: (req: NextRequest) => Promise<string | null>;
+    /** Collection name (default: 'blogs') */
+    collectionName?: string;
+    /** Site ID for multi-site setups */
+    siteId?: string;
+}
+/**
+ * Handle blog API requests
+ * Routes requests to appropriate handlers based on path
+ * Similar to plugin-dep, accepts config directly instead of requiring initialization
+ */
+export declare function handleBlogApi(req: NextRequest, path: string[], config: BlogApiRouterConfig): Promise<NextResponse>;
+//# sourceMappingURL=router.d.ts.map

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

@@ -0,0 +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;AAKxD,MAAM,WAAW,mBAAmB;IAChC,oEAAoE;IACpE,KAAK,EAAE,MAAM,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,GAAG,CAAA;KAAE,CAAC,CAAC;IACxC,yDAAyD;IACzD,SAAS,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACxD,yCAAyC;IACzC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oCAAoC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAC/B,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CA2FvB"}

package/dist/api/router.js

@@ -0,0 +1,98 @@
+'use server';
+/**
+ * Plugin Blog API Router
+ * Centralized API handler for all blog plugin routes
+ *
+ * This router handles requests to /api/plugin-blog/*
+ * and routes them to the appropriate handler
+ */
+import { NextResponse } from 'next/server';
+import { GET as BlogListHandler, POST as BlogCreateHandler } from './handler';
+import { GET as BlogGetHandler, PUT as BlogUpdateHandler, DELETE as BlogDeleteHandler, createBlogApiConfig } from './route';
+import { GET as ConfigGetHandler, POST as ConfigPostHandler } from './config-handler';
+/**
+ * Handle blog API requests
+ * Routes requests to appropriate handlers based on path
+ * Similar to plugin-dep, accepts config directly instead of requiring initialization
+ */
+export async function handleBlogApi(req, path, config) {
+    // Create the blog API config from the router config
+    const blogApiConfig = createBlogApiConfig({
+        getDb: config.getDb,
+        getUserId: config.getUserId,
+        collectionName: config.collectionName || 'blogs',
+    });
+    const method = req.method;
+    // Handle empty path array - means we're at /api/plugin-blog
+    // Ensure path is always an array
+    const safePath = Array.isArray(path) ? path : [];
+    const route = safePath.length > 0 ? safePath[0] : '';
+    try {
+        // Route: /api/plugin-blog (list/create) - empty path or 'list'
+        // This handles both /api/plugin-blog and /api/plugin-blog?limit=3
+        if (!route || route === 'list') {
+            if (method === 'GET') {
+                return await BlogListHandler(req, blogApiConfig);
+            }
+            if (method === 'POST') {
+                return await BlogCreateHandler(req, blogApiConfig);
+            }
+            // Method not allowed for root route
+            return NextResponse.json({ error: `Method ${method} not allowed for route: /` }, { status: 405 });
+        }
+        // Route: /api/plugin-blog/new (create new)
+        else if (route === 'new') {
+            if (method === 'POST') {
+                return await BlogCreateHandler(req, blogApiConfig);
+            }
+        }
+        // Route: /api/plugin-blog/categories (get categories)
+        else if (route === 'categories') {
+            if (method === 'GET') {
+                // Import categories handler
+                const categoriesModule = await import('./categories');
+                return await categoriesModule.GET(req, blogApiConfig);
+            }
+        }
+        // Route: /api/plugin-blog/check-title (check title duplicate)
+        else if (route === 'check-title') {
+            if (method === 'GET') {
+                const checkTitleModule = await import('./check-title');
+                return await checkTitleModule.GET(req, blogApiConfig);
+            }
+        }
+        // Route: /api/plugin-blog/config (get/save plugin config)
+        else if (route === 'config') {
+            const configApiConfig = {
+                getDb: config.getDb,
+                getUserId: config.getUserId,
+                siteId: config.siteId || 'default',
+            };
+            if (method === 'GET') {
+                return await ConfigGetHandler(req, configApiConfig);
+            }
+            if (method === 'POST') {
+                return await ConfigPostHandler(req, configApiConfig);
+            }
+        }
+        // Route: /api/plugin-blog/[slug] (get/update/delete by slug)
+        else {
+            const slug = route;
+            if (method === 'GET') {
+                return await BlogGetHandler(req, { params: Promise.resolve({ slug }) }, blogApiConfig);
+            }
+            if (method === 'PUT') {
+                return await BlogUpdateHandler(req, { params: Promise.resolve({ slug }) }, blogApiConfig);
+            }
+            if (method === 'DELETE') {
+                return await BlogDeleteHandler(req, { params: Promise.resolve({ slug }) }, blogApiConfig);
+            }
+        }
+        // Method not allowed
+        return NextResponse.json({ error: `Method ${method} not allowed for route: ${route || '/'}` }, { status: 405 });
+    }
+    catch (error) {
+        console.error('[BlogApiRouter] Error:', error);
+        return NextResponse.json({ error: error.message || 'Internal server error' }, { status: 500 });
+    }
+}

package/dist/api-server.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Plugin Blog - Server-Only API Exports
+ * This file is only imported in server-side code (API routes)
+ *
+ * IMPORTANT: This file uses Node.js modules (fs, path, etc.) and should NEVER
+ * be imported in client-side code. Only use in server-side API routes.
+ */
+export * from './api';
+//# sourceMappingURL=api-server.d.ts.map

package/dist/api-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-server.d.ts","sourceRoot":"","sources":["../src/api-server.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,cAAc,OAAO,CAAC"}

package/dist/api-server.js

@@ -0,0 +1,9 @@
+/**
+ * Plugin Blog - Server-Only API Exports
+ * This file is only imported in server-side code (API routes)
+ *
+ * IMPORTANT: This file uses Node.js modules (fs, path, etc.) and should NEVER
+ * be imported in client-side code. Only use in server-side API routes.
+ */
+// Re-export everything from the API index
+export * from './api';

package/dist/config.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Plugin Blog Configuration
+ * Automatically creates required API routes in client apps
+ */
+/**
+ * Automatically creates plugin-blog API catch-all route
+ * This route forwards requests to the plugin's API router
+ */
+/**
+ * @deprecated Routes are now handled by the unified /api/[pluginId]/[...path]/route.ts
+ * This function is kept for backwards compatibility but does nothing
+ */
+export declare function ensureBlogRoutes(): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH;;;GAGG;AACH;;;GAGG;AACH,wBAAgB,gBAAgB,SAgJ/B"}

package/dist/config.js

@@ -0,0 +1,156 @@
+/**
+ * Plugin Blog Configuration
+ * Automatically creates required API routes in client apps
+ */
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+/**
+ * Automatically creates plugin-blog API catch-all route
+ * This route forwards requests to the plugin's API router
+ */
+/**
+ * @deprecated Routes are now handled by the unified /api/[pluginId]/[...path]/route.ts
+ * This function is kept for backwards compatibility but does nothing
+ */
+export function ensureBlogRoutes() {
+    // Routes are now handled by the unified /api/[pluginId]/[...path]/route.ts
+    // No need to generate individual routes anymore
+    return;
+    try {
+        // Find the host app directory (where next.config.ts is)
+        let appDir = process.cwd();
+        const possiblePaths = [
+            appDir,
+            join(appDir, '..'),
+            join(appDir, '..', '..'),
+        ];
+        for (const basePath of possiblePaths) {
+            const configPath = join(basePath, 'next.config.ts');
+            if (existsSync(configPath)) {
+                appDir = basePath;
+                break;
+            }
+        }
+        const apiDir = join(appDir, 'src', 'app', 'api');
+        const pluginBlogApiDir = join(apiDir, 'plugin-blog', '[...path]');
+        const pluginBlogApiPath = join(pluginBlogApiDir, 'route.ts');
+        // Check if route already exists
+        if (existsSync(pluginBlogApiPath)) {
+            const fs = require('fs');
+            const existingContent = fs.readFileSync(pluginBlogApiPath, 'utf8');
+            if (existingContent.includes('@jhits/plugin-blog') || existingContent.includes('plugin-blog')) {
+                // Already set up, skip
+                return;
+            }
+        }
+        // Create plugin-blog API catch-all route
+        mkdirSync(pluginBlogApiDir, { recursive: true });
+        writeFileSync(pluginBlogApiPath, `// Auto-generated by @jhits/plugin-blog - Blog Plugin API
+// This route is automatically created for the blog plugin
+import { NextRequest } from 'next/server';
+import { handleBlogApi } from '@jhits/plugin-blog/api';
+import { MongoClient } from 'mongodb';
+import { cookies } from 'next/headers';
+import jwt from 'jsonwebtoken';
+
+const JWT_SECRET = process.env.JWT_SECRET || 'secret';
+const MONGODB_URI = process.env.MONGODB_URI || process.env.MONGO_URI || '';
+
+// MongoDB client singleton
+let client: MongoClient | null = null;
+let clientPromise: Promise<MongoClient>;
+
+if (!MONGODB_URI) {
+    throw new Error('Please add MONGODB_URI to your .env.local file');
+}
+
+if (process.env.NODE_ENV === 'development') {
+    const globalWithMongo = global as typeof globalThis & {
+        _mongoClientPromise?: Promise<MongoClient>;
+    };
+
+    if (!globalWithMongo._mongoClientPromise) {
+        client = new MongoClient(MONGODB_URI);
+        globalWithMongo._mongoClientPromise = client.connect();
+    }
+    clientPromise = globalWithMongo._mongoClientPromise;
+} else {
+    client = new MongoClient(MONGODB_URI);
+    clientPromise = client.connect();
+}
+
+async function getUserId(req: NextRequest): Promise<string | null> {
+    try {
+        const cookieStore = await cookies();
+        const token = cookieStore.get('auth_token')?.value;
+        if (!token) return null;
+        const decoded = jwt.verify(token, JWT_SECRET) as { id: string };
+        return decoded.id;
+    } catch {
+        return null;
+    }
+}
+
+// Get the API config
+function getBlogApiConfig() {
+    return {
+        getDb: async () => {
+            const client = await clientPromise;
+            return { db: () => client.db() };
+        },
+        getUserId,
+        collectionName: 'blogs',
+    };
+}
+
+export async function GET(
+    req: NextRequest,
+    { params }: { params: Promise<{ path: string[] }> }
+) {
+    const { path } = await params;
+    const config = getBlogApiConfig();
+    return handleBlogApi(req, path, config);
+}
+
+export async function POST(
+    req: NextRequest,
+    { params }: { params: Promise<{ path: string[] }> }
+) {
+    const { path } = await params;
+    const config = getBlogApiConfig();
+    return handleBlogApi(req, path, config);
+}
+
+export async function PUT(
+    req: NextRequest,
+    { params }: { params: Promise<{ path: string[] }> }
+) {
+    ensureInitialized();
+    const { path } = await params;
+    return handleBlogApi(req, path);
+}
+
+export async function DELETE(
+    req: NextRequest,
+    { params }: { params: Promise<{ path: string[] }> }
+) {
+    ensureInitialized();
+    const { path } = await params;
+    return handleBlogApi(req, path);
+}
+
+export async function PATCH(
+    req: NextRequest,
+    { params }: { params: Promise<{ path: string[] }> }
+) {
+    ensureInitialized();
+    const { path } = await params;
+    return handleBlogApi(req, path);
+}
+`);
+    }
+    catch (error) {
+        // Ignore errors - route might already exist or app structure is different
+        console.warn('[plugin-blog] Could not ensure blog routes:', error);
+    }
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Blog Hooks
+ * React hooks for fetching blog data in client applications
+ */
+export { useBlogs, type UseBlogsOptions, type UseBlogsResult } from './useBlogs';
+export { useBlog, type UseBlogOptions, type UseBlogResult } from './useBlog';
+export { useCategories } from './useCategories';
+//# 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;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AACjF,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/hooks/index.js

@@ -0,0 +1,7 @@
+/**
+ * Blog Hooks
+ * React hooks for fetching blog data in client applications
+ */
+export { useBlogs } from './useBlogs';
+export { useBlog } from './useBlog';
+export { useCategories } from './useCategories';

package/dist/hooks/useBlog.d.ts

@@ -0,0 +1,31 @@
+/**
+ * useBlog Hook
+ * React hook for fetching a single blog post by slug
+ */
+import { BlogPost } from '../types/post';
+export interface UseBlogOptions {
+    /** Blog post slug */
+    slug: string;
+    /** API base URL (default: '/api/blogs') */
+    apiBaseUrl?: string;
+}
+export interface UseBlogResult {
+    /** Blog post data */
+    blog: BlogPost | null;
+    /** Whether data is currently loading */
+    loading: boolean;
+    /** Error message if fetch failed */
+    error: string | null;
+    /** Function to refetch the blog post */
+    refetch: () => Promise<void>;
+}
+/**
+ * React hook to fetch a single blog post by slug
+ *
+ * @example
+ * ```tsx
+ * const { blog, loading, error } = useBlog({ slug: 'my-blog-post' });
+ * ```
+ */
+export declare function useBlog(options: UseBlogOptions): UseBlogResult;
+//# sourceMappingURL=useBlog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useBlog.d.ts","sourceRoot":"","sources":["../../src/hooks/useBlog.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,MAAM,WAAW,cAAc;IAC3B,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC1B,qBAAqB;IACrB,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;IACtB,wCAAwC;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,oCAAoC;IACpC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,wCAAwC;IACxC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,aAAa,CAgD9D"}

package/dist/hooks/useBlog.js

@@ -0,0 +1,57 @@
+/**
+ * useBlog Hook
+ * React hook for fetching a single blog post by slug
+ */
+import { useState, useEffect } from 'react';
+import { apiToBlogPost } from '../lib/mappers/apiMapper';
+/**
+ * React hook to fetch a single blog post by slug
+ *
+ * @example
+ * ```tsx
+ * const { blog, loading, error } = useBlog({ slug: 'my-blog-post' });
+ * ```
+ */
+export function useBlog(options) {
+    const { slug, apiBaseUrl = '/api/plugin-blog' } = options;
+    const [blog, setBlog] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const fetchBlog = async () => {
+        if (!slug) {
+            setLoading(false);
+            return;
+        }
+        try {
+            setLoading(true);
+            setError(null);
+            const response = await fetch(`${apiBaseUrl}/${slug}`);
+            if (!response.ok) {
+                if (response.status === 404) {
+                    throw new Error('Blog post not found');
+                }
+                throw new Error(`Failed to fetch blog: ${response.status}`);
+            }
+            const apiDoc = await response.json();
+            const blogPost = apiToBlogPost(apiDoc);
+            setBlog(blogPost);
+        }
+        catch (err) {
+            console.error('[useBlog] Error fetching blog:', err);
+            setError(err.message || 'Failed to fetch blog');
+            setBlog(null);
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    useEffect(() => {
+        fetchBlog();
+    }, [slug, apiBaseUrl]);
+    return {
+        blog,
+        loading,
+        error,
+        refetch: fetchBlog,
+    };
+}

package/dist/hooks/useBlogs.d.ts

@@ -0,0 +1,39 @@
+/**
+ * useBlogs Hook
+ * React hook for fetching blog posts in client applications
+ */
+import { PostListItem } from '../types/post';
+export interface UseBlogsOptions {
+    /** Maximum number of posts to fetch (default: 10) */
+    limit?: number;
+    /** Number of posts to skip (default: 0) */
+    skip?: number;
+    /** Filter by status (published, draft, concept) */
+    status?: string;
+    /** Whether to fetch all posts for admin (includes drafts) */
+    admin?: boolean;
+    /** API base URL (default: '/api/blogs') */
+    apiBaseUrl?: string;
+}
+export interface UseBlogsResult {
+    /** Array of blog posts */
+    blogs: PostListItem[];
+    /** Whether data is currently loading */
+    loading: boolean;
+    /** Error message if fetch failed */
+    error: string | null;
+    /** Total number of posts available */
+    total: number;
+    /** Function to refetch blogs */
+    refetch: () => Promise<void>;
+}
+/**
+ * React hook to fetch blog posts
+ *
+ * @example
+ * ```tsx
+ * const { blogs, loading, error } = useBlogs({ limit: 5 });
+ * ```
+ */
+export declare function useBlogs(options?: UseBlogsOptions): UseBlogsResult;
+//# sourceMappingURL=useBlogs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useBlogs.d.ts","sourceRoot":"","sources":["../../src/hooks/useBlogs.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,MAAM,WAAW,eAAe;IAC5B,qDAAqD;IACrD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,2CAA2C;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC3B,0BAA0B;IAC1B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,wCAAwC;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,oCAAoC;IACpC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,gCAAgC;IAChC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,OAAO,GAAE,eAAoB,GAAG,cAAc,CA8EtE"}

package/dist/hooks/useBlogs.js

@@ -0,0 +1,82 @@
+/**
+ * useBlogs Hook
+ * React hook for fetching blog posts in client applications
+ */
+import { useState, useEffect } from 'react';
+import { apiToBlogPost } from '../lib/mappers/apiMapper';
+/**
+ * React hook to fetch blog posts
+ *
+ * @example
+ * ```tsx
+ * const { blogs, loading, error } = useBlogs({ limit: 5 });
+ * ```
+ */
+export function useBlogs(options = {}) {
+    const { limit = 10, skip = 0, status, admin = false, apiBaseUrl = '/api/plugin-blog', } = options;
+    const [blogs, setBlogs] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const [total, setTotal] = useState(0);
+    const fetchBlogs = async () => {
+        try {
+            setLoading(true);
+            setError(null);
+            const params = new URLSearchParams();
+            if (limit)
+                params.set('limit', limit.toString());
+            if (skip)
+                params.set('skip', skip.toString());
+            if (status)
+                params.set('status', status);
+            if (admin)
+                params.set('admin', 'true');
+            const url = `${apiBaseUrl}?${params.toString()}`;
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch blogs: ${response.status}`);
+            }
+            const data = await response.json();
+            // Handle error response
+            if (data.error) {
+                throw new Error(data.error || 'Failed to fetch blogs');
+            }
+            // Convert API format to PostListItem format
+            const blogsArray = Array.isArray(data.blogs) ? data.blogs : [];
+            const convertedBlogs = blogsArray.map((apiDoc) => {
+                const blogPost = apiToBlogPost(apiDoc);
+                return {
+                    id: blogPost.id,
+                    title: blogPost.title,
+                    slug: blogPost.slug,
+                    excerpt: blogPost.metadata.excerpt || '',
+                    status: blogPost.publication.status,
+                    authorId: blogPost.publication.authorId || '',
+                    updatedAt: blogPost.updatedAt,
+                    featuredImage: blogPost.metadata.featuredImage,
+                };
+            });
+            setBlogs(convertedBlogs);
+            setTotal(data.total || convertedBlogs.length);
+        }
+        catch (err) {
+            console.error('[useBlogs] Error fetching blogs:', err);
+            setError(err.message || 'Failed to fetch blogs');
+            setBlogs([]);
+            setTotal(0);
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    useEffect(() => {
+        fetchBlogs();
+    }, [limit, skip, status, admin, apiBaseUrl]);
+    return {
+        blogs,
+        loading,
+        error,
+        total,
+        refetch: fetchBlogs,
+    };
+}

package/dist/hooks/useCategories.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hook to fetch categories from existing blog posts
+ * Extracts categories from Hero blocks in all posts
+ */
+export declare function useCategories(): {
+    categories: string[];
+    loading: boolean;
+};
+//# sourceMappingURL=useCategories.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCategories.d.ts","sourceRoot":"","sources":["../../src/hooks/useCategories.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,wBAAgB,aAAa;;;EAkE5B"}