@jhits/plugin-blog 0.0.19 → 0.0.20

package/dist/state/EditorContext.js

@@ -1,215 +1,165 @@
 /**
  * Editor Context
- * React Context for managing editor state
- * Multi-Tenant: Accepts custom blocks from client applications
+ * Enhanced with language management and simplified state handling
  */
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useReducer, useCallback, useMemo, useEffect, useRef, useState } from 'react';
+import { createContext, useContext, useReducer, useMemo, useEffect, useRef, useState } from 'react';
 import { editorReducer } from './reducer';
 import { initialEditorState } from './types';
+import { apiToBlogPost } from '../lib/mappers/apiMapper';
 import { blockRegistry } from '../registry/BlockRegistry';
 import { registerLayoutBlocks } from '../lib/layouts/registerLayoutBlocks';
-// Create the context
+const API_BASE_URL = process.env.NEXT_PUBLIC_DASHBOARD_URL || 'http://localhost:3001';
 const EditorContext = createContext(null);
-/**
- * Editor Provider
- * Provides editor state and actions to child components
- * Automatically registers client-provided blocks on mount
- */
-export function EditorProvider({ children, initialState, onSave, customBlocks = [], darkMode = true, backgroundColors }) {
-    // Register core layout blocks on mount
-    useEffect(() => {
-        registerLayoutBlocks();
-    }, []);
-    // Register client blocks on mount
-    useEffect(() => {
-        if (customBlocks && customBlocks.length > 0) {
-            try {
-                blockRegistry.registerClientBlocks(customBlocks);
-            }
-            catch (error) {
-                console.error('[EditorContext] Failed to register custom blocks:', error);
-            }
-        }
-    }, [customBlocks]);
+export function EditorProvider({ children, initialState, onSave, customBlocks = [], darkMode = false, backgroundColors, translations }) {
+    useEffect(() => { registerLayoutBlocks(); }, []);
+    useEffect(() => { if (customBlocks?.length)
+        blockRegistry.registerClientBlocks(customBlocks); }, [customBlocks]);
     const [state, dispatch] = useReducer(editorReducer, { ...initialEditorState, ...initialState });
-    // Use a ref to always have access to the latest state in callbacks
+    const [user, setUser] = useState(null);
     const stateRef = useRef(state);
     stateRef.current = state;
-    // History state for undo/redo
+    // Language Management
+    const [availableLanguages, setAvailableLanguages] = useState([]);
+    useEffect(() => {
+        const fetchUser = async () => {
+            try {
+                const res = await fetch(`${API_BASE_URL}/api/me`);
+                if (res.ok) {
+                    const data = await res.json();
+                    if (data.user)
+                        setUser(data.user);
+                }
+            }
+            catch (e) { }
+        };
+        fetchUser();
+    }, []);
+    // History logic (Simplified)
     const [history, setHistory] = useState([]);
     const [historyIndex, setHistoryIndex] = useState(-1);
     const isRestoringRef = useRef(false);
-    const MAX_HISTORY = 50; // Limit history to prevent memory issues
-    // Save current state to history after state changes (but not during undo/redo)
-    // Debounce history updates to avoid excessive re-renders
-    const historyTimeoutRef = useRef(null);
     useEffect(() => {
         if (isRestoringRef.current) {
             isRestoringRef.current = false;
             return;
         }
-        // Clear existing timeout
-        if (historyTimeoutRef.current) {
-            clearTimeout(historyTimeoutRef.current);
-        }
-        // Debounce history updates to reduce re-renders
-        historyTimeoutRef.current = setTimeout(() => {
-            // Save current state to history
+        const timer = setTimeout(() => {
             setHistory(prev => {
-                const newHistory = [...prev];
-                // Remove any future history if we're not at the end
-                if (historyIndex < newHistory.length - 1) {
-                    newHistory.splice(historyIndex + 1);
-                }
-                // Add current state
-                newHistory.push({ ...state });
-                // Limit history size
-                if (newHistory.length > MAX_HISTORY) {
-                    newHistory.shift();
-                    return newHistory;
-                }
-                return newHistory;
+                const next = prev.slice(0, historyIndex + 1);
+                next.push({ ...state });
+                return next.slice(-50);
             });
-            setHistoryIndex(prev => {
-                const newIndex = prev + 1;
-                return newIndex >= MAX_HISTORY ? MAX_HISTORY - 1 : newIndex;
-            });
-        }, 300); // Debounce by 300ms
-        return () => {
-            if (historyTimeoutRef.current) {
-                clearTimeout(historyTimeoutRef.current);
+            setHistoryIndex(prev => Math.min(prev + 1, 49));
+        }, 300);
+        return () => clearTimeout(timer);
+    }, [state.blocks, state.title, state.slug]);
+    const helpers = useMemo(() => ({
+        addBlock: (type, index, containerId) => {
+            const def = blockRegistry.get(type);
+            const block = {
+                id: `block-${Date.now()}`,
+                type,
+                data: { ...(def?.defaultData || {}) }
+            };
+            dispatch({ type: 'ADD_BLOCK', payload: { block, index, containerId } });
+        },
+        updateBlock: (id, data) => dispatch({ type: 'UPDATE_BLOCK', payload: { id, data } }),
+        deleteBlock: (id) => dispatch({ type: 'DELETE_BLOCK', payload: { id } }),
+        duplicateBlock: (id) => dispatch({ type: 'DUPLICATE_BLOCK', payload: { id } }),
+        moveBlock: (id, newIndex, containerId) => dispatch({ type: 'MOVE_BLOCK', payload: { id, newIndex, containerId } }),
+        loadPost: (post) => {
+            dispatch({ type: 'LOAD_POST', payload: post });
+            // 1. Collect all unique language keys from the post data
+            const createdLangs = new Set();
+            // From availableLanguages array (source of truth from API)
+            if (post.availableLanguages) {
+                post.availableLanguages.forEach(l => createdLangs.add(l));
             }
-        };
-    }, [state.blocks, state.title, state.slug, state.seo, state.metadata, state.status, historyIndex]);
-    // Helper: Add a new block (supports nested containers)
-    const addBlock = useCallback((type, index, containerId) => {
-        const blockDefinition = blockRegistry.get(type);
-        if (!blockDefinition) {
-            console.warn(`Block type "${type}" not found in registry. Available types:`, blockRegistry.getAll().map(b => b.type).join(', '));
-            return;
-        }
-        const newBlock = {
-            id: `block-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-            type,
-            data: { ...blockDefinition.defaultData },
-        };
-        dispatch({ type: 'ADD_BLOCK', payload: { block: newBlock, index, containerId } });
-    }, []);
-    // Helper: Update a block
-    const updateBlock = useCallback((id, data) => {
-        dispatch({ type: 'UPDATE_BLOCK', payload: { id, data } });
-    }, []);
-    // Helper: Delete a block
-    const deleteBlock = useCallback((id) => {
-        dispatch({ type: 'DELETE_BLOCK', payload: { id } });
-    }, []);
-    // Helper: Duplicate a block
-    const duplicateBlock = useCallback((id) => {
-        dispatch({ type: 'DUPLICATE_BLOCK', payload: { id } });
-    }, []);
-    // Helper: Move a block (supports nested containers)
-    const moveBlock = useCallback((id, newIndex, containerId) => {
-        dispatch({ type: 'MOVE_BLOCK', payload: { id, newIndex, containerId } });
-    }, []);
-    // Helper: Load a post
-    const loadPost = useCallback((post) => {
-        dispatch({ type: 'LOAD_POST', payload: post });
-    }, []);
-    // Helper: Reset editor
-    const resetEditor = useCallback(() => {
-        dispatch({ type: 'RESET_EDITOR' });
-    }, []);
-    // Helper: Save
-    // Uses stateRef to always get the latest state, avoiding stale closure issues
-    const save = useCallback(async (heroBlock) => {
-        if (onSave) {
-            // Use stateRef.current to get the absolute latest state
-            // This ensures we don't have stale closure issues with React state updates
-            await onSave(stateRef.current, heroBlock);
-            dispatch({ type: 'MARK_CLEAN' });
-        }
-    }, [onSave]);
-    // Helper: Undo
-    const undo = useCallback(() => {
-        if (historyIndex > 0 && history.length > 0) {
-            const previousState = history[historyIndex - 1];
-            if (previousState) {
+            // From languages summary keys (backup)
+            if (post.languages) {
+                Object.keys(post.languages).forEach(l => createdLangs.add(l));
+            }
+            // 2. Update state with the consolidated list
+            setAvailableLanguages(Array.from(createdLangs));
+        },
+        resetEditor: () => dispatch({ type: 'RESET_EDITOR' }),
+        save: async (heroBlock, statusOverride) => {
+            if (onSave) {
+                const currentState = { ...stateRef.current };
+                if (statusOverride)
+                    currentState.status = statusOverride;
+                await onSave(currentState, heroBlock);
+                dispatch({ type: 'MARK_CLEAN' });
+            }
+        },
+        undo: () => {
+            if (historyIndex > 0) {
                 isRestoringRef.current = true;
-                setHistoryIndex(prev => prev - 1);
-                dispatch({ type: 'LOAD_POST', payload: {
-                        id: previousState.postId || '',
-                        title: previousState.title,
-                        slug: previousState.slug,
-                        blocks: previousState.blocks,
-                        seo: previousState.seo,
-                        publication: {
-                            status: previousState.status,
-                            authorId: undefined,
-                        },
-                        metadata: previousState.metadata,
-                        createdAt: new Date().toISOString(),
-                        updatedAt: new Date().toISOString(),
-                    } });
+                const prev = history[historyIndex - 1];
+                setHistoryIndex(i => i - 1);
+                dispatch({ type: 'LOAD_POST', payload: prev });
             }
-        }
-    }, [history, historyIndex, dispatch]);
-    // Helper: Redo
-    const redo = useCallback(() => {
-        if (historyIndex < history.length - 1) {
-            const nextState = history[historyIndex + 1];
-            if (nextState) {
+        },
+        redo: () => {
+            if (historyIndex < history.length - 1) {
                 isRestoringRef.current = true;
-                setHistoryIndex(prev => prev + 1);
-                dispatch({ type: 'LOAD_POST', payload: {
-                        id: nextState.postId || '',
-                        title: nextState.title,
-                        slug: nextState.slug,
-                        blocks: nextState.blocks,
-                        seo: nextState.seo,
-                        publication: {
-                            status: nextState.status,
-                            authorId: undefined,
-                        },
-                        metadata: nextState.metadata,
-                        createdAt: new Date().toISOString(),
-                        updatedAt: new Date().toISOString(),
-                    } });
+                const next = history[historyIndex + 1];
+                setHistoryIndex(i => i + 1);
+                dispatch({ type: 'LOAD_POST', payload: next });
+            }
+        },
+        switchLanguage: async (newLang, postId) => {
+            // 1. Always update the current language in state first to show immediate UI feedback
+            dispatch({ type: 'SET_CURRENT_LANGUAGE', payload: newLang });
+            if (!postId) {
+                dispatch({ type: 'SET_STATUS', payload: 'draft' });
+                return;
+            }
+            // 2. Fetch the language version from the API
+            const fetchUrl = `${API_BASE_URL}/api/plugin-blog/${postId}?language=${newLang}&admin=true`;
+            const res = await fetch(fetchUrl);
+            if (res.ok) {
+                const data = await res.json();
+                const blogPost = apiToBlogPost(data);
+                // Update the available languages list from the source of truth
+                if (data.availableLanguages) {
+                    setAvailableLanguages(data.availableLanguages);
+                }
+                // If this is a NEW translation (missing in the document),
+                // customize it so it's not a perfect clone of the primary language
+                if (data.isMissingTranslation) {
+                    blogPost.publication.status = 'draft';
+                    blogPost.title = `${blogPost.title} - ${newLang.toUpperCase()}`;
+                    // Important: Mark as dirty so it can be saved as a new version
+                    dispatch({ type: 'LOAD_POST', payload: blogPost });
+                    dispatch({ type: 'MARK_DIRTY' });
+                }
+                else {
+                    dispatch({ type: 'LOAD_POST', payload: blogPost });
+                    dispatch({ type: 'MARK_CLEAN' });
+                }
             }
         }
-    }, [history, historyIndex, dispatch]);
-    // Memoize the context value
+    }), [onSave, history, historyIndex, state.postId]);
     const value = useMemo(() => ({
         state,
         dispatch,
         darkMode,
         backgroundColors,
-        helpers: {
-            addBlock,
-            updateBlock,
-            deleteBlock,
-            duplicateBlock,
-            moveBlock,
-            loadPost,
-            resetEditor,
-            save,
-            undo,
-            redo,
-        },
-        canUndo: historyIndex > 0 && history.length > 0,
+        translations,
+        user,
+        helpers,
+        availableLanguages,
+        canUndo: historyIndex > 0,
         canRedo: historyIndex < history.length - 1,
-    }), [state, dispatch, darkMode, backgroundColors, addBlock, updateBlock, deleteBlock, duplicateBlock, moveBlock, loadPost, resetEditor, save, undo, redo, historyIndex, history.length]);
+    }), [state, darkMode, backgroundColors, user, helpers, historyIndex, history.length, availableLanguages]);
     return _jsx(EditorContext.Provider, { value: value, children: children });
 }
-/**
- * Hook to access editor context
- * @throws Error if used outside EditorProvider
- */
 export function useEditor() {
     const context = useContext(EditorContext);
-    if (!context) {
-        throw new Error('useEditor must be used within an EditorProvider');
-    }
+    if (!context)
+        throw new Error('useEditor must be used within EditorProvider');
     return context;
 }

package/dist/state/reducer.d.ts

@@ -1,11 +1,7 @@
 /**
  * Editor Reducer
- * Pure function that handles state transitions
+ * Pure function that handles state transitions using tree utilities
  */
 import { EditorState, EditorAction } from './types';
-/**
- * Editor Reducer
- * Handles all state transitions for the editor
- */
 export declare function editorReducer(state: EditorState, action: EditorAction): EditorState;
 //# sourceMappingURL=reducer.d.ts.map

package/dist/state/reducer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../src/state/reducer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAsB,MAAM,SAAS,CAAC;AAqUxE;;;GAGG;AACH,wBAAgB,aAAa,CACzB,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,YAAY,GACrB,WAAW,CAyWb"}
+{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../src/state/reducer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAsB,MAAM,SAAS,CAAC;AA+BxE,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,WAAW,CAsMnF"}