@lobehub/lobehub 2.0.0-next.254 → 2.0.0-next.256

package/src/store/document/slices/editor/index.ts

@@ -1,3 +1,10 @@
-export { createEditorSlice, type EditorAction } from './action';
-export { type EditorState,initialEditorState } from './initialState';
+export { createEditorSlice, type EditorAction, type SaveMetadata } from './action';
+export {
+  createInitialEditorContentState,
+  type DocumentSourceType,
+  type EditorContentState,
+  type EditorState,
+  initialEditorState,
+} from './initialState';
+export { type DocumentDispatch,documentReducer } from './reducer';
 export { editorSelectors } from './selectors';

package/src/store/document/slices/editor/initialState.ts

@@ -1,26 +1,31 @@
+'use client';
+
 import { type IEditor } from '@lobehub/editor';
+import { type EditorState as LobehubEditorState } from '@lobehub/editor/react';
 
-export interface EditorState {
-  /**
-   * Current document content (markdown)
-   */
-  activeContent: string;
-  /**
-   * Current document ID being edited
-   */
-  activeDocumentId: string | undefined;
+/**
+ * Document source type - determines which service to use for persistence
+ */
+export type DocumentSourceType = 'notebook' | 'page';
+
+/**
+ * Editor content state for a single document
+ * Only contains editor-related state, NOT document metadata (title, emoji, etc.)
+ */
+export interface EditorContentState {
   /**
-   * Current topic ID for the active document
+   * Whether auto-save is enabled for this document
+   * Defaults to true. Set to false if the consumer handles saving themselves.
    */
-  activeTopicId: string | undefined;
+  autoSave?: boolean;
   /**
-   * Editor instance from @lobehub/editor
+   * Document content (markdown)
    */
-  editor: IEditor | undefined;
+  content: string;
   /**
-   * Editor state from useEditorState hook
+   * Editor JSON data (BlockNote format)
    */
-  editorState: any;
+  editorData: any;
   /**
    * Whether there are unsaved changes
    */
@@ -33,30 +38,62 @@ export interface EditorState {
    * Last updated time
    */
   lastUpdatedTime: Date | null;
-  /**
-   * Edit mode: 'edit' or 'preview'
-   */
-  mode: 'edit' | 'preview';
   /**
    * Current save status
    */
   saveStatus: 'idle' | 'saving' | 'saved';
   /**
-   * Current document title
+   * Document source type - determines which service to call for persistence
    */
-  title: string;
+  sourceType: DocumentSourceType;
+  /**
+   * Topic ID (for notebook documents, used for save routing)
+   */
+  topicId?: string;
 }
 
-export const initialEditorState: EditorState = {
-  activeContent: '',
-  activeDocumentId: undefined,
-  activeTopicId: undefined,
-  editor: undefined,
-  editorState: undefined,
+/**
+ * Global editor state
+ */
+export interface EditorState {
+  /**
+   * Currently active document ID
+   */
+  activeDocumentId: string | undefined;
+  /**
+   * Map of editor content states by document ID
+   */
+  documents: Record<string, EditorContentState>;
+  /**
+   * Shared editor instance
+   */
+  editor: IEditor | undefined;
+  /**
+   * Editor state from useEditorState hook
+   */
+  editorState: LobehubEditorState | undefined;
+}
+
+/**
+ * Create initial state for a new document's editor content
+ */
+export const createInitialEditorContentState = (
+  sourceType: DocumentSourceType,
+  overrides?: Partial<EditorContentState>,
+): EditorContentState => ({
+  content: '',
+  editorData: null,
   isDirty: false,
   lastSavedContent: '',
   lastUpdatedTime: null,
-  mode: 'edit',
   saveStatus: 'idle',
-  title: '',
+  sourceType,
+  ...overrides,
+});
+
+export const initialEditorState: EditorState = {
+  activeDocumentId: undefined,
+  documents: {},
+  editor: undefined,
+  editorState: undefined,
 };

package/src/store/document/slices/editor/reducer.test.ts

@@ -0,0 +1,217 @@
+import { describe, expect, it } from 'vitest';
+
+import { type EditorContentState } from './initialState';
+import { type DocumentDispatch, documentReducer } from './reducer';
+
+describe('documentReducer', () => {
+  let state: Record<string, EditorContentState>;
+
+  beforeEach(() => {
+    state = {};
+  });
+
+  describe('addDocument', () => {
+    it('should add a new document to state', () => {
+      const payload: DocumentDispatch = {
+        id: 'doc-1',
+        type: 'addDocument',
+        value: { sourceType: 'page' },
+      };
+
+      const newState = documentReducer(state, payload);
+
+      expect(newState['doc-1']).toBeDefined();
+      expect(newState['doc-1'].sourceType).toBe('page');
+      expect(newState['doc-1'].isDirty).toBe(false);
+      expect(newState['doc-1'].saveStatus).toBe('idle');
+    });
+
+    it('should add document with all provided values', () => {
+      const payload: DocumentDispatch = {
+        id: 'doc-1',
+        type: 'addDocument',
+        value: {
+          autoSave: false,
+          content: '# Test content',
+          editorData: { type: 'doc' },
+          lastSavedContent: '# Test content',
+          sourceType: 'notebook',
+          topicId: 'topic-1',
+        },
+      };
+
+      const newState = documentReducer(state, payload);
+
+      expect(newState['doc-1']).toMatchObject({
+        autoSave: false,
+        content: '# Test content',
+        editorData: { type: 'doc' },
+        isDirty: false,
+        lastSavedContent: '# Test content',
+        sourceType: 'notebook',
+        topicId: 'topic-1',
+      });
+    });
+
+    it('should merge with existing document when ID exists', () => {
+      // First add a document
+      const initialPayload: DocumentDispatch = {
+        id: 'doc-1',
+        type: 'addDocument',
+        value: { content: 'Original', sourceType: 'page' },
+      };
+      state = documentReducer(state, initialPayload);
+
+      // Then add again with same ID
+      const updatePayload: DocumentDispatch = {
+        id: 'doc-1',
+        type: 'addDocument',
+        value: { content: 'Updated', sourceType: 'page' },
+      };
+      const newState = documentReducer(state, updatePayload);
+
+      expect(newState['doc-1'].content).toBe('Updated');
+    });
+  });
+
+  describe('updateDocument', () => {
+    it('should update an existing document', () => {
+      // First add a document
+      const addPayload: DocumentDispatch = {
+        id: 'doc-1',
+        type: 'addDocument',
+        value: { content: 'Original', sourceType: 'page' },
+      };
+      state = documentReducer(state, addPayload);
+
+      // Then update it
+      const updatePayload: DocumentDispatch = {
+        id: 'doc-1',
+        type: 'updateDocument',
+        value: { content: 'Updated', isDirty: true },
+      };
+      const newState = documentReducer(state, updatePayload);
+
+      expect(newState['doc-1'].content).toBe('Updated');
+      expect(newState['doc-1'].isDirty).toBe(true);
+    });
+
+    it('should not modify state if document does not exist', () => {
+      const payload: DocumentDispatch = {
+        id: 'non-existent',
+        type: 'updateDocument',
+        value: { content: 'Test' },
+      };
+
+      const newState = documentReducer(state, payload);
+
+      expect(newState['non-existent']).toBeUndefined();
+      expect(newState).toBe(state);
+    });
+
+    it('should not create new state reference if values are equal', () => {
+      // First add a document
+      const addPayload: DocumentDispatch = {
+        id: 'doc-1',
+        type: 'addDocument',
+        value: { content: 'Test', sourceType: 'page' },
+      };
+      state = documentReducer(state, addPayload);
+
+      // Update with same value
+      const updatePayload: DocumentDispatch = {
+        id: 'doc-1',
+        type: 'updateDocument',
+        value: { content: 'Test' },
+      };
+      const newState = documentReducer(state, updatePayload);
+
+      // Should be the same reference since nothing changed
+      expect(newState).toBe(state);
+    });
+  });
+
+  describe('deleteDocument', () => {
+    it('should delete an existing document', () => {
+      // First add a document
+      const addPayload: DocumentDispatch = {
+        id: 'doc-1',
+        type: 'addDocument',
+        value: { sourceType: 'page' },
+      };
+      state = documentReducer(state, addPayload);
+      expect(state['doc-1']).toBeDefined();
+
+      // Then delete it
+      const deletePayload: DocumentDispatch = {
+        id: 'doc-1',
+        type: 'deleteDocument',
+      };
+      const newState = documentReducer(state, deletePayload);
+
+      expect(newState['doc-1']).toBeUndefined();
+    });
+
+    it('should not affect other documents when deleting one', () => {
+      // Add two documents
+      state = documentReducer(state, {
+        id: 'doc-1',
+        type: 'addDocument',
+        value: { sourceType: 'page' },
+      });
+      state = documentReducer(state, {
+        id: 'doc-2',
+        type: 'addDocument',
+        value: { sourceType: 'notebook' },
+      });
+
+      // Delete one
+      const newState = documentReducer(state, {
+        id: 'doc-1',
+        type: 'deleteDocument',
+      });
+
+      expect(newState['doc-1']).toBeUndefined();
+      expect(newState['doc-2']).toBeDefined();
+    });
+  });
+
+  describe('default', () => {
+    it('should return the original state for unknown action type', () => {
+      const payload = {
+        id: 'doc-1',
+        type: 'unknown',
+      } as unknown as DocumentDispatch;
+
+      const newState = documentReducer(state, payload);
+
+      expect(newState).toBe(state);
+    });
+  });
+
+  describe('immutability', () => {
+    it('should generate immutable state object', () => {
+      const payload: DocumentDispatch = {
+        id: 'doc-1',
+        type: 'addDocument',
+        value: { sourceType: 'page' },
+      };
+
+      const newState = documentReducer(state, payload);
+
+      expect(newState).not.toBe(state);
+    });
+
+    it('should not modify the original state object', () => {
+      const payload: DocumentDispatch = {
+        id: 'doc-1',
+        type: 'addDocument',
+        value: { sourceType: 'page' },
+      };
+
+      documentReducer(state, payload);
+
+      expect(state).toEqual({});
+    });
+  });
+});

package/src/store/document/slices/editor/reducer.ts

@@ -0,0 +1,67 @@
+import { produce } from 'immer';
+
+import { type EditorContentState, createInitialEditorContentState } from './initialState';
+
+// ============ Action Types ============
+
+interface AddDocumentAction {
+  id: string;
+  type: 'addDocument';
+  value: Partial<EditorContentState> & { sourceType: EditorContentState['sourceType'] };
+}
+
+interface UpdateDocumentAction {
+  id: string;
+  type: 'updateDocument';
+  value: Partial<EditorContentState>;
+}
+
+interface DeleteDocumentAction {
+  id: string;
+  type: 'deleteDocument';
+}
+
+export type DocumentDispatch = AddDocumentAction | UpdateDocumentAction | DeleteDocumentAction;
+
+// ============ Reducer ============
+
+export const documentReducer = (
+  state: Record<string, EditorContentState> = {},
+  payload: DocumentDispatch,
+): Record<string, EditorContentState> => {
+  switch (payload.type) {
+    case 'addDocument': {
+      return produce(state, (draft) => {
+        const { id, value } = payload;
+        const existingDoc = draft[id];
+
+        // Create new document state, merging with existing if present
+        draft[id] = existingDoc
+          ? { ...existingDoc, ...value }
+          : createInitialEditorContentState(value.sourceType, value);
+      });
+    }
+
+    case 'updateDocument': {
+      return produce(state, (draft) => {
+        const { id, value } = payload;
+        const currentDoc = draft[id];
+
+        if (currentDoc) {
+          // Directly assign to let immer handle change detection
+          Object.assign(draft[id], value);
+        }
+      });
+    }
+
+    case 'deleteDocument': {
+      return produce(state, (draft) => {
+        delete draft[payload.id];
+      });
+    }
+
+    default: {
+      return state;
+    }
+  }
+};