@jhits/plugin-newsletter 0.0.4 → 0.0.6

package/dist/state/reducer.js

@@ -0,0 +1,488 @@
+/**
+ * Newsletter Editor Reducer
+ * Pure function that handles state transitions
+ */
+import { initialEditorState } from './types';
+/**
+ * Generate a unique block ID
+ */
+function generateBlockId() {
+    // 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) {
+    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.map(cloneBlock)
+            : [...block.children]) : undefined,
+    };
+}
+/**
+ * Find a block by ID recursively (including nested blocks)
+ */
+function findBlockById(blocks, id) {
+    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, id);
+                if (found)
+                    return found;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Update blocks recursively to add a block to a container
+ */
+function addBlockToContainer(blocks, containerId, newBlock, index) {
+    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
+                    : [])
+                : [];
+            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
+                    : [])
+                : [];
+            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, containerId, newBlock, index),
+                };
+            }
+        }
+        return block;
+    });
+}
+/**
+ * Update blocks recursively to update a nested block
+ */
+function updateNestedBlock(blocks, id, data) {
+    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, id, data),
+                };
+            }
+        }
+        return block;
+    });
+}
+/**
+ * Delete a nested block recursively
+ */
+function deleteNestedBlock(blocks, id) {
+    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;
+                // 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, containerId, blockId, newIndex) {
+    return blocks.map(block => {
+        if (block.id === containerId && block.children && Array.isArray(block.children)) {
+            const children = typeof block.children[0] === 'object'
+                ? block.children
+                : [];
+            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, containerId, blockId, newIndex),
+                };
+            }
+        }
+        return block;
+    });
+}
+/**
+ * Remove a block from the tree and return it
+ */
+function removeBlockFromTree(blocks, id) {
+    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, 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, blockId, containerId, newIndex) {
+    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, action) {
+    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,
+                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
+                        : [];
+                    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/dist/state/types.d.ts

@@ -0,0 +1,157 @@
+/**
+ * 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 declare const initialEditorState: EditorState;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/state/types.ts"],"names":[],"mappings":"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"}

package/dist/state/types.js

@@ -0,0 +1,26 @@
+/**
+ * State Management Types for Newsletter Plugin
+ * Types for the editor state management system
+ */
+/**
+ * Initial Editor State
+ */
+export const initialEditorState = {
+    blocks: [],
+    title: '',
+    slug: '',
+    metadata: {
+        subject: '',
+        previewText: '',
+        lang: 'en',
+        recipientFilter: {
+            type: 'all',
+        },
+    },
+    status: 'draft',
+    isDirty: false,
+    focusMode: false,
+    selectedBlockId: null,
+    draggedBlockId: null,
+    newsletterId: null,
+};