@jhits/plugin-newsletter 0.0.7 → 0.0.8

package/src/state/reducer.ts

@@ -1,561 +0,0 @@
-/**
- * Newsletter Editor Reducer
- * Pure function that handles state transitions
- */
-
-import { EditorState, EditorAction, initialEditorState } from './types';
-import { Block } from '../types/block';
-
-/**
- * Generate a unique block ID
- */
-function generateBlockId(): string {
-    // Use crypto.randomUUID if available, otherwise fallback to timestamp-based
-    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
-        return crypto.randomUUID();
-    }
-    return `block-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-}
-
-/**
- * Clone a block with a new ID
- */
-function cloneBlock(block: Block): Block {
-    return {
-        ...block,
-        id: generateBlockId(),
-        data: { ...block.data },
-        meta: block.meta ? { ...block.meta } : undefined,
-        children: block.children ? (Array.isArray(block.children) && block.children.length > 0 && typeof block.children[0] === 'object'
-            ? (block.children as Block[]).map(cloneBlock)
-            : [...(block.children as string[])]) : undefined,
-    };
-}
-
-/**
- * Find a block by ID recursively (including nested blocks)
- */
-function findBlockById(blocks: Block[], id: string): Block | null {
-    for (const block of blocks) {
-        if (block.id === id) {
-            return block;
-        }
-        if (block.children && Array.isArray(block.children) && block.children.length > 0) {
-            // Check if children are Block objects or IDs
-            if (typeof block.children[0] === 'object') {
-                const found = findBlockById(block.children as Block[], id);
-                if (found) return found;
-            }
-        }
-    }
-    return null;
-}
-
-/**
- * Update blocks recursively to add a block to a container
- */
-function addBlockToContainer(
-    blocks: Block[],
-    containerId: string,
-    newBlock: Block,
-    index?: number
-): Block[] {
-    return blocks.map(block => {
-        // Check if this is the container (exact match or column container like "block-123-col-0")
-        const isContainer = block.id === containerId;
-        const isColumnContainer = containerId.startsWith(`${block.id}-col-`);
-        
-        if (isContainer) {
-            // Direct container match
-            const currentChildren = Array.isArray(block.children) 
-                ? (typeof block.children[0] === 'object' 
-                    ? block.children as Block[]
-                    : []) 
-                : [];
-            const updatedChildren = [...currentChildren];
-            if (index !== undefined && index >= 0 && index <= updatedChildren.length) {
-                updatedChildren.splice(index, 0, newBlock);
-            } else {
-                updatedChildren.push(newBlock);
-            }
-            return {
-                ...block,
-                children: updatedChildren,
-            };
-        } else if (isColumnContainer) {
-            // Column container - extract column index and store in block meta
-            const columnIndex = parseInt(containerId.split('-col-')[1] || '0', 10);
-            newBlock.meta = {
-                ...newBlock.meta,
-                columnIndex,
-            };
-            
-            const currentChildren = Array.isArray(block.children) 
-                ? (typeof block.children[0] === 'object' 
-                    ? block.children as Block[]
-                    : []) 
-                : [];
-            const updatedChildren = [...currentChildren];
-            if (index !== undefined && index >= 0 && index <= updatedChildren.length) {
-                updatedChildren.splice(index, 0, newBlock);
-            } else {
-                updatedChildren.push(newBlock);
-            }
-            return {
-                ...block,
-                children: updatedChildren,
-            };
-        }
-        
-        // Recursively search nested blocks
-        if (block.children && Array.isArray(block.children) && block.children.length > 0) {
-            if (typeof block.children[0] === 'object') {
-                return {
-                    ...block,
-                    children: addBlockToContainer(block.children as Block[], containerId, newBlock, index),
-                };
-            }
-        }
-        return block;
-    });
-}
-
-/**
- * Update blocks recursively to update a nested block
- */
-function updateNestedBlock(
-    blocks: Block[],
-    id: string,
-    data: Partial<Block['data']>
-): Block[] {
-    return blocks.map(block => {
-        if (block.id === id) {
-            return {
-                ...block,
-                data: { ...block.data, ...data },
-            };
-        }
-        if (block.children && Array.isArray(block.children) && block.children.length > 0) {
-            if (typeof block.children[0] === 'object') {
-                return {
-                    ...block,
-                    children: updateNestedBlock(block.children as Block[], id, data),
-                };
-            }
-        }
-        return block;
-    });
-}
-
-/**
- * Delete a nested block recursively
- */
-function deleteNestedBlock(blocks: Block[], id: string): Block[] {
-    return blocks.map(block => {
-        if (block.children && Array.isArray(block.children) && block.children.length > 0) {
-            if (typeof block.children[0] === 'object') {
-                const children = block.children as Block[];
-                // Check if any child matches
-                if (children.some(child => child.id === id)) {
-                    return {
-                        ...block,
-                        children: children.filter(child => child.id !== id),
-                    };
-                }
-                // Recursively search
-                return {
-                    ...block,
-                    children: deleteNestedBlock(children, id),
-                };
-            }
-        }
-        return block;
-    });
-}
-
-/**
- * Move a nested block within a container
- */
-function moveNestedBlock(
-    blocks: Block[],
-    containerId: string,
-    blockId: string,
-    newIndex: number
-): Block[] {
-    return blocks.map(block => {
-        if (block.id === containerId && block.children && Array.isArray(block.children)) {
-            const children = typeof block.children[0] === 'object' 
-                ? block.children as Block[]
-                : [];
-            const currentIndex = children.findIndex(b => b.id === blockId);
-            if (currentIndex !== -1 && currentIndex !== newIndex) {
-                const newChildren = [...children];
-                const [moved] = newChildren.splice(currentIndex, 1);
-                newChildren.splice(newIndex, 0, moved);
-                return {
-                    ...block,
-                    children: newChildren,
-                };
-            }
-        }
-        if (block.children && Array.isArray(block.children) && block.children.length > 0) {
-            if (typeof block.children[0] === 'object') {
-                return {
-                    ...block,
-                    children: moveNestedBlock(block.children as Block[], containerId, blockId, newIndex),
-                };
-            }
-        }
-        return block;
-    });
-}
-
-/**
- * Remove a block from the tree and return it
- */
-function removeBlockFromTree(blocks: Block[], id: string): { updatedBlocks: Block[]; removedBlock: Block | null } {
-    for (let i = 0; i < blocks.length; i++) {
-        const block = blocks[i];
-        if (!block) continue;
-        
-        if (block.id === id) {
-            const removed = block;
-            const updated = [...blocks];
-            updated.splice(i, 1);
-            return { updatedBlocks: updated, removedBlock: removed };
-        }
-        if (block.children && Array.isArray(block.children) && block.children.length > 0) {
-            const firstChild = block.children[0];
-            if (firstChild && typeof firstChild === 'object') {
-                const result = removeBlockFromTree(block.children as Block[], id);
-                if (result.removedBlock) {
-                    return {
-                        updatedBlocks: blocks.map((b, idx) => 
-                            idx === i 
-                                ? { ...b, children: result.updatedBlocks }
-                                : b
-                        ),
-                        removedBlock: result.removedBlock,
-                    };
-                }
-            }
-        }
-    }
-    return { updatedBlocks: blocks, removedBlock: null };
-}
-
-/**
- * Move a block to a container
- */
-function moveBlockToContainer(
-    blocks: Block[],
-    blockId: string,
-    containerId: string,
-    newIndex: number
-): Block[] {
-    const { updatedBlocks, removedBlock } = removeBlockFromTree(blocks, blockId);
-    if (!removedBlock) return blocks;
-    
-    return addBlockToContainer(updatedBlocks, containerId, removedBlock, newIndex);
-}
-
-/**
- * Editor Reducer
- * Handles all state transitions for the editor
- */
-export function editorReducer(
-    state: EditorState,
-    action: EditorAction
-): EditorState {
-    switch (action.type) {
-        case 'SET_BLOCKS':
-            return {
-                ...state,
-                blocks: action.payload,
-                isDirty: true,
-            };
-
-        case 'ADD_BLOCK': {
-            const { block, index, containerId } = action.payload;
-            const newBlock: Block = {
-                ...block,
-                id: block.id || generateBlockId(),
-            };
-            
-            // If containerId is provided, add to container's children
-            if (containerId) {
-                const updatedBlocks = addBlockToContainer(state.blocks, containerId, newBlock, index);
-                return {
-                    ...state,
-                    blocks: updatedBlocks,
-                    selectedBlockId: newBlock.id,
-                    isDirty: true,
-                };
-            }
-            
-            // Otherwise, add to root level
-            const newBlocks = [...state.blocks];
-            if (index !== undefined && index >= 0 && index <= newBlocks.length) {
-                newBlocks.splice(index, 0, newBlock);
-            } else {
-                newBlocks.push(newBlock);
-            }
-            
-            return {
-                ...state,
-                blocks: newBlocks,
-                selectedBlockId: newBlock.id,
-                isDirty: true,
-            };
-        }
-
-        case 'UPDATE_BLOCK': {
-            const { id, data } = action.payload;
-            // Check if block is at root level
-            const rootBlock = state.blocks.find(block => block.id === id);
-            if (rootBlock) {
-                const newBlocks = state.blocks.map(block =>
-                    block.id === id
-                        ? {
-                              ...block,
-                              data: { ...block.data, ...data },
-                          }
-                        : block
-                );
-                return {
-                    ...state,
-                    blocks: newBlocks,
-                    isDirty: true,
-                };
-            }
-            
-            // Otherwise, update nested block
-            const newBlocks = updateNestedBlock(state.blocks, id, data);
-            return {
-                ...state,
-                blocks: newBlocks,
-                isDirty: true,
-            };
-        }
-
-        case 'DELETE_BLOCK': {
-            const { id } = action.payload;
-            // Check if block is at root level
-            const rootBlock = state.blocks.find(block => block.id === id);
-            if (rootBlock) {
-                const newBlocks = state.blocks.filter(block => block.id !== id);
-                const wasSelected = state.selectedBlockId === id;
-                return {
-                    ...state,
-                    blocks: newBlocks,
-                    selectedBlockId: wasSelected ? null : state.selectedBlockId,
-                    isDirty: true,
-                };
-            }
-            
-            // Otherwise, delete nested block
-            const newBlocks = deleteNestedBlock(state.blocks, id);
-            const wasSelected = state.selectedBlockId === id;
-            return {
-                ...state,
-                blocks: newBlocks,
-                selectedBlockId: wasSelected ? null : state.selectedBlockId,
-                isDirty: true,
-            };
-        }
-
-        case 'DUPLICATE_BLOCK': {
-            const { id } = action.payload;
-            const blockIndex = state.blocks.findIndex(block => block.id === id);
-            
-            if (blockIndex === -1) {
-                return state;
-            }
-            
-            const blockToDuplicate = state.blocks[blockIndex];
-            const duplicatedBlock = cloneBlock(blockToDuplicate);
-            
-            const newBlocks = [...state.blocks];
-            newBlocks.splice(blockIndex + 1, 0, duplicatedBlock);
-            
-            return {
-                ...state,
-                blocks: newBlocks,
-                selectedBlockId: duplicatedBlock.id,
-                isDirty: true,
-            };
-        }
-
-        case 'MOVE_BLOCK': {
-            const { id, newIndex, containerId: rawContainerId } = action.payload;
-            
-            // Normalize 'root' string to undefined
-            const containerId = rawContainerId === 'root' || rawContainerId === undefined ? undefined : rawContainerId;
-            
-            // If containerId is provided (and not 'root'), move to/within container
-            if (containerId) {
-                const containerBlock = findBlockById(state.blocks, containerId);
-                
-                if (containerBlock && containerBlock.children && Array.isArray(containerBlock.children)) {
-                    const children = typeof containerBlock.children[0] === 'object' 
-                        ? containerBlock.children as Block[]
-                        : [];
-                    const currentIndex = children.findIndex(b => b.id === id);
-                    
-                    if (currentIndex !== -1) {
-                        // Block is already in this container - move within container
-                        const newBlocks = moveNestedBlock(state.blocks, containerId, id, newIndex);
-                        return {
-                            ...state,
-                            blocks: newBlocks,
-                            isDirty: true,
-                        };
-                    }
-                }
-                
-                // Block is not in this container - move it from wherever it is
-                const newBlocks = moveBlockToContainer(state.blocks, id, containerId, newIndex);
-                return {
-                    ...state,
-                    blocks: newBlocks,
-                    isDirty: true,
-                };
-            }
-            
-            // Moving to root level (containerId is undefined)
-            const currentIndex = state.blocks.findIndex(block => block.id === id);
-            
-            if (currentIndex !== -1) {
-                // Block is at root level - move within root
-                const newBlocks = [...state.blocks];
-                const [moved] = newBlocks.splice(currentIndex, 1);
-                if (newIndex >= 0 && newIndex <= newBlocks.length) {
-                    newBlocks.splice(newIndex, 0, moved);
-                } else {
-                    newBlocks.push(moved);
-                }
-                return {
-                    ...state,
-                    blocks: newBlocks,
-                    isDirty: true,
-                };
-            }
-            
-            // Block is nested somewhere - move it to root level
-            const { updatedBlocks, removedBlock } = removeBlockFromTree(state.blocks, id);
-            
-            if (removedBlock) {
-                // Clear any nested metadata (like columnIndex)
-                const cleanedBlock = {
-                    ...removedBlock,
-                    meta: removedBlock.meta ? {
-                        ...removedBlock.meta,
-                        columnIndex: undefined,
-                    } : undefined,
-                };
-                
-                const newBlocks = [...updatedBlocks];
-                if (newIndex >= 0 && newIndex <= newBlocks.length) {
-                    newBlocks.splice(newIndex, 0, cleanedBlock);
-                } else {
-                    newBlocks.push(cleanedBlock);
-                }
-                
-                return {
-                    ...state,
-                    blocks: newBlocks,
-                    isDirty: true,
-                };
-            }
-            
-            return state;
-        }
-
-        case 'SET_TITLE':
-            return {
-                ...state,
-                title: action.payload,
-                isDirty: true,
-            };
-
-        case 'SET_SLUG':
-            return {
-                ...state,
-                slug: action.payload,
-                isDirty: true,
-            };
-
-        case 'SET_METADATA':
-            return {
-                ...state,
-                metadata: { ...state.metadata, ...action.payload },
-                isDirty: true,
-            };
-
-        case 'SET_STATUS':
-            return {
-                ...state,
-                status: action.payload,
-                isDirty: true,
-            };
-
-        case 'SET_FOCUS_MODE':
-            return {
-                ...state,
-                focusMode: action.payload,
-            };
-
-        case 'SELECT_BLOCK':
-            return {
-                ...state,
-                selectedBlockId: action.payload,
-            };
-
-        case 'SET_DRAGGED_BLOCK':
-            return {
-                ...state,
-                draggedBlockId: action.payload,
-            };
-
-        case 'LOAD_NEWSLETTER': {
-            const newsletter = action.payload;
-            return {
-                ...state,
-                blocks: newsletter.blocks,
-                title: newsletter.title,
-                slug: newsletter.slug,
-                metadata: newsletter.metadata,
-                status: newsletter.publication.status,
-                newsletterId: newsletter.id,
-                isDirty: false,
-                selectedBlockId: null,
-            };
-        }
-
-        case 'RESET_EDITOR':
-            return {
-                ...initialEditorState,
-            };
-
-        case 'MARK_CLEAN':
-            return {
-                ...state,
-                isDirty: false,
-            };
-
-        case 'MARK_DIRTY':
-            return {
-                ...state,
-                isDirty: true,
-            };
-
-        case 'UNDO':
-        case 'REDO':
-        case 'SAVE_HISTORY':
-            // These are handled by the context, not the reducer
-            return state;
-
-        default:
-            return state;
-    }
-}

package/src/state/types.ts

@@ -1,154 +0,0 @@
-/**
- * State Management Types for Newsletter Plugin
- * Types for the editor state management system
- */
-
-import { Block } from '../types/block';
-import { Newsletter, NewsletterStatus, NewsletterMetadata } from '../types/newsletter';
-
-/**
- * Editor State
- * Represents the current state of the newsletter editor
- */
-export interface EditorState {
-    /** Array of blocks in the editor */
-    blocks: Block[];
-    
-    /** Newsletter title */
-    title: string;
-    
-    /** Newsletter slug */
-    slug: string;
-    
-    /** Newsletter metadata */
-    metadata: NewsletterMetadata;
-    
-    /** Publication status */
-    status: NewsletterStatus;
-    
-    /** Whether the newsletter has unsaved changes */
-    isDirty: boolean;
-    
-    /** Whether the editor is in focus mode */
-    focusMode: boolean;
-    
-    /** Currently selected block ID */
-    selectedBlockId: string | null;
-    
-    /** Currently dragged block ID */
-    draggedBlockId: string | null;
-    
-    /** Newsletter ID (if editing existing newsletter) */
-    newsletterId: string | null;
-}
-
-/**
- * Editor Actions
- * Actions that can be dispatched to modify editor state
- */
-export type EditorAction =
-    | { type: 'SET_BLOCKS'; payload: Block[] }
-    | { type: 'ADD_BLOCK'; payload: { block: Block; index?: number; containerId?: string } }
-    | { type: 'UPDATE_BLOCK'; payload: { id: string; data: Partial<Block['data']> } }
-    | { type: 'DELETE_BLOCK'; payload: { id: string } }
-    | { type: 'DUPLICATE_BLOCK'; payload: { id: string } }
-    | { type: 'MOVE_BLOCK'; payload: { id: string; newIndex: number; containerId?: string } }
-    | { type: 'SET_TITLE'; payload: string }
-    | { type: 'SET_SLUG'; payload: string }
-    | { type: 'SET_METADATA'; payload: Partial<NewsletterMetadata> }
-    | { type: 'SET_STATUS'; payload: NewsletterStatus }
-    | { type: 'SET_FOCUS_MODE'; payload: boolean }
-    | { type: 'SELECT_BLOCK'; payload: string | null }
-    | { type: 'SET_DRAGGED_BLOCK'; payload: string | null }
-    | { type: 'LOAD_NEWSLETTER'; payload: Newsletter }
-    | { type: 'RESET_EDITOR' }
-    | { type: 'MARK_CLEAN' }
-    | { type: 'MARK_DIRTY' }
-    | { type: 'UNDO' }
-    | { type: 'REDO' }
-    | { type: 'SAVE_HISTORY' };
-
-/**
- * Editor Context Value
- * The value provided by the EditorContext
- */
-export interface EditorContextValue {
-    /** Current editor state */
-    state: EditorState;
-    
-    /** Dispatch an action to modify state */
-    dispatch: (action: EditorAction) => void;
-    
-    /** Enable dark mode for content area and wrappers */
-    darkMode: boolean;
-    
-    /** Background colors for the editor */
-    backgroundColors?: {
-        /** Background color for light mode (REQUIRED) */
-        light: string;
-        /** Background color for dark mode (optional) */
-        dark?: string;
-    };
-    
-    /** Helper functions for common operations */
-    helpers: {
-        /** Add a new block (supports nested containers via containerId) */
-        addBlock: (type: string, index?: number, containerId?: string) => void;
-        
-        /** Update a block's data */
-        updateBlock: (id: string, data: Partial<Block['data']>) => void;
-        
-        /** Delete a block */
-        deleteBlock: (id: string) => void;
-        
-        /** Duplicate a block */
-        duplicateBlock: (id: string) => void;
-        
-        /** Move a block to a new position (supports nested containers via containerId) */
-        moveBlock: (id: string, newIndex: number, containerId?: string) => void;
-        
-        /** Load a newsletter into the editor */
-        loadNewsletter: (newsletter: Newsletter) => void;
-        
-        /** Reset editor to initial state */
-        resetEditor: () => void;
-        
-        /** Save current state (triggers save callback) */
-        save: () => Promise<void>;
-        
-        /** Undo last action */
-        undo: () => void;
-        
-        /** Redo last undone action */
-        redo: () => void;
-    };
-    
-    /** Whether undo is available */
-    canUndo: boolean;
-    
-    /** Whether redo is available */
-    canRedo: boolean;
-}
-
-/**
- * Initial Editor State
- */
-export const initialEditorState: EditorState = {
-    blocks: [],
-    title: '',
-    slug: '',
-    metadata: {
-        subject: '',
-        previewText: '',
-        lang: 'en',
-        recipientFilter: {
-            type: 'all',
-        },
-    },
-    status: 'draft',
-    isDirty: false,
-    focusMode: false,
-    selectedBlockId: null,
-    draggedBlockId: null,
-    newsletterId: null,
-};