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

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

@@ -0,0 +1,395 @@
+import { describe, expect, it } from 'vitest';
+
+import type { DocumentStore } from '../../store';
+import { editorSelectors } from './selectors';
+
+describe('DocumentStore - Editor Selectors', () => {
+  const createMockState = (overrides?: Partial<DocumentStore>): DocumentStore =>
+    ({
+      activeDocumentId: undefined,
+      documents: {},
+      editor: undefined,
+      editorState: undefined,
+      ...overrides,
+    }) as DocumentStore;
+
+  describe('activeDocumentId', () => {
+    it('should return undefined when no document is active', () => {
+      const state = createMockState();
+      expect(editorSelectors.activeDocumentId(state)).toBeUndefined();
+    });
+
+    it('should return the active document ID', () => {
+      const state = createMockState({ activeDocumentId: 'doc-1' });
+      expect(editorSelectors.activeDocumentId(state)).toBe('doc-1');
+    });
+  });
+
+  describe('activeDocument', () => {
+    it('should return undefined when no document is active', () => {
+      const state = createMockState();
+      expect(editorSelectors.activeDocument(state)).toBeUndefined();
+    });
+
+    it('should return the active document', () => {
+      const doc = {
+        content: 'Hello',
+        editorData: null,
+        isDirty: false,
+        lastSavedContent: 'Hello',
+        lastUpdatedTime: null,
+        saveStatus: 'idle' as const,
+        sourceType: 'notebook' as const,
+      };
+      const state = createMockState({
+        activeDocumentId: 'doc-1',
+        documents: { 'doc-1': doc },
+      });
+      expect(editorSelectors.activeDocument(state)).toEqual(doc);
+    });
+  });
+
+  describe('isEditing', () => {
+    it('should return false when no document is active', () => {
+      const state = createMockState();
+      expect(editorSelectors.isEditing(state)).toBe(false);
+    });
+
+    it('should return true when a document is active', () => {
+      const state = createMockState({ activeDocumentId: 'doc-1' });
+      expect(editorSelectors.isEditing(state)).toBe(true);
+    });
+  });
+
+  describe('documentById', () => {
+    it('should return undefined for non-existent document', () => {
+      const state = createMockState();
+      expect(editorSelectors.documentById('non-existent')(state)).toBeUndefined();
+    });
+
+    it('should return the document by ID', () => {
+      const doc = {
+        content: 'Test',
+        editorData: null,
+        isDirty: false,
+        lastSavedContent: 'Test',
+        lastUpdatedTime: null,
+        saveStatus: 'idle' as const,
+        sourceType: 'page' as const,
+      };
+      const state = createMockState({
+        documents: { 'doc-1': doc },
+      });
+      expect(editorSelectors.documentById('doc-1')(state)).toEqual(doc);
+    });
+  });
+
+  describe('isDirty', () => {
+    it('should return false for non-existent document', () => {
+      const state = createMockState();
+      expect(editorSelectors.isDirty('non-existent')(state)).toBe(false);
+    });
+
+    it('should return isDirty status', () => {
+      const state = createMockState({
+        documents: {
+          'doc-1': {
+            content: '',
+            editorData: null,
+            isDirty: true,
+            lastSavedContent: '',
+            lastUpdatedTime: null,
+            saveStatus: 'idle' as const,
+            sourceType: 'notebook' as const,
+          },
+        },
+      });
+      expect(editorSelectors.isDirty('doc-1')(state)).toBe(true);
+    });
+  });
+
+  describe('saveStatus', () => {
+    it('should return idle for non-existent document', () => {
+      const state = createMockState();
+      expect(editorSelectors.saveStatus('non-existent')(state)).toBe('idle');
+    });
+
+    it('should return save status', () => {
+      const state = createMockState({
+        documents: {
+          'doc-1': {
+            content: '',
+            editorData: null,
+            isDirty: false,
+            lastSavedContent: '',
+            lastUpdatedTime: null,
+            saveStatus: 'saving' as const,
+            sourceType: 'notebook' as const,
+          },
+        },
+      });
+      expect(editorSelectors.saveStatus('doc-1')(state)).toBe('saving');
+    });
+  });
+
+  describe('content', () => {
+    it('should return empty string for non-existent document', () => {
+      const state = createMockState();
+      expect(editorSelectors.content('non-existent')(state)).toBe('');
+    });
+
+    it('should return content', () => {
+      const state = createMockState({
+        documents: {
+          'doc-1': {
+            content: '# Hello',
+            editorData: null,
+            isDirty: false,
+            lastSavedContent: '',
+            lastUpdatedTime: null,
+            saveStatus: 'idle' as const,
+            sourceType: 'notebook' as const,
+          },
+        },
+      });
+      expect(editorSelectors.content('doc-1')(state)).toBe('# Hello');
+    });
+  });
+
+  describe('editorData', () => {
+    it('should return undefined for non-existent document', () => {
+      const state = createMockState();
+      expect(editorSelectors.editorData('non-existent')(state)).toBeUndefined();
+    });
+
+    it('should return editorData', () => {
+      const mockEditorData = { type: 'doc', content: [] };
+      const state = createMockState({
+        documents: {
+          'doc-1': {
+            content: '',
+            editorData: mockEditorData,
+            isDirty: false,
+            lastSavedContent: '',
+            lastUpdatedTime: null,
+            saveStatus: 'idle' as const,
+            sourceType: 'page' as const,
+          },
+        },
+      });
+      expect(editorSelectors.editorData('doc-1')(state)).toEqual(mockEditorData);
+    });
+  });
+
+  describe('sourceType', () => {
+    it('should return undefined for non-existent document', () => {
+      const state = createMockState();
+      expect(editorSelectors.sourceType('non-existent')(state)).toBeUndefined();
+    });
+
+    it('should return sourceType', () => {
+      const state = createMockState({
+        documents: {
+          'doc-1': {
+            content: '',
+            editorData: null,
+            isDirty: false,
+            lastSavedContent: '',
+            lastUpdatedTime: null,
+            saveStatus: 'idle' as const,
+            sourceType: 'page' as const,
+          },
+        },
+      });
+      expect(editorSelectors.sourceType('doc-1')(state)).toBe('page');
+    });
+  });
+
+  describe('activeIsDirty', () => {
+    it('should return false when no document is active', () => {
+      const state = createMockState();
+      expect(editorSelectors.activeIsDirty(state)).toBe(false);
+    });
+
+    it('should return isDirty of active document', () => {
+      const state = createMockState({
+        activeDocumentId: 'doc-1',
+        documents: {
+          'doc-1': {
+            content: '',
+            editorData: null,
+            isDirty: true,
+            lastSavedContent: '',
+            lastUpdatedTime: null,
+            saveStatus: 'idle' as const,
+            sourceType: 'notebook' as const,
+          },
+        },
+      });
+      expect(editorSelectors.activeIsDirty(state)).toBe(true);
+    });
+  });
+
+  describe('activeContent', () => {
+    it('should return empty string when no document is active', () => {
+      const state = createMockState();
+      expect(editorSelectors.activeContent(state)).toBe('');
+    });
+
+    it('should return content of active document', () => {
+      const state = createMockState({
+        activeDocumentId: 'doc-1',
+        documents: {
+          'doc-1': {
+            content: '# Active Doc',
+            editorData: null,
+            isDirty: false,
+            lastSavedContent: '',
+            lastUpdatedTime: null,
+            saveStatus: 'idle' as const,
+            sourceType: 'notebook' as const,
+          },
+        },
+      });
+      expect(editorSelectors.activeContent(state)).toBe('# Active Doc');
+    });
+  });
+
+  describe('canSave', () => {
+    it('should return false when no document is active', () => {
+      const state = createMockState();
+      expect(editorSelectors.canSave(state)).toBeFalsy();
+    });
+
+    it('should return false when document is not dirty', () => {
+      const state = createMockState({
+        activeDocumentId: 'doc-1',
+        documents: {
+          'doc-1': {
+            content: '',
+            editorData: null,
+            isDirty: false,
+            lastSavedContent: '',
+            lastUpdatedTime: null,
+            saveStatus: 'idle' as const,
+            sourceType: 'notebook' as const,
+          },
+        },
+      });
+      expect(editorSelectors.canSave(state)).toBeFalsy();
+    });
+
+    it('should return false when document is saving', () => {
+      const state = createMockState({
+        activeDocumentId: 'doc-1',
+        documents: {
+          'doc-1': {
+            content: '',
+            editorData: null,
+            isDirty: true,
+            lastSavedContent: '',
+            lastUpdatedTime: null,
+            saveStatus: 'saving' as const,
+            sourceType: 'notebook' as const,
+          },
+        },
+      });
+      expect(editorSelectors.canSave(state)).toBeFalsy();
+    });
+
+    it('should return true when document is dirty and not saving', () => {
+      const state = createMockState({
+        activeDocumentId: 'doc-1',
+        documents: {
+          'doc-1': {
+            content: '',
+            editorData: null,
+            isDirty: true,
+            lastSavedContent: '',
+            lastUpdatedTime: null,
+            saveStatus: 'idle' as const,
+            sourceType: 'notebook' as const,
+          },
+        },
+      });
+      expect(editorSelectors.canSave(state)).toBe(true);
+    });
+  });
+
+  describe('documentIds', () => {
+    it('should return empty array when no documents', () => {
+      const state = createMockState();
+      expect(editorSelectors.documentIds(state)).toEqual([]);
+    });
+
+    it('should return all document IDs', () => {
+      const state = createMockState({
+        documents: {
+          'doc-1': {} as any,
+          'doc-2': {} as any,
+        },
+      });
+      expect(editorSelectors.documentIds(state)).toEqual(['doc-1', 'doc-2']);
+    });
+  });
+
+  describe('documentCount', () => {
+    it('should return 0 when no documents', () => {
+      const state = createMockState();
+      expect(editorSelectors.documentCount(state)).toBe(0);
+    });
+
+    it('should return document count', () => {
+      const state = createMockState({
+        documents: {
+          'doc-1': {} as any,
+          'doc-2': {} as any,
+          'doc-3': {} as any,
+        },
+      });
+      expect(editorSelectors.documentCount(state)).toBe(3);
+    });
+  });
+
+  describe('hasDocument', () => {
+    it('should return false for non-existent document', () => {
+      const state = createMockState();
+      expect(editorSelectors.hasDocument('non-existent')(state)).toBe(false);
+    });
+
+    it('should return true for existing document', () => {
+      const state = createMockState({
+        documents: {
+          'doc-1': {} as any,
+        },
+      });
+      expect(editorSelectors.hasDocument('doc-1')(state)).toBe(true);
+    });
+  });
+
+  describe('editor', () => {
+    it('should return undefined when no editor', () => {
+      const state = createMockState();
+      expect(editorSelectors.editor(state)).toBeUndefined();
+    });
+
+    it('should return editor instance', () => {
+      const mockEditor = { focus: () => {} } as any;
+      const state = createMockState({ editor: mockEditor });
+      expect(editorSelectors.editor(state)).toBe(mockEditor);
+    });
+  });
+
+  describe('editorState', () => {
+    it('should return undefined when no editorState', () => {
+      const state = createMockState();
+      expect(editorSelectors.editorState(state)).toBeUndefined();
+    });
+
+    it('should return editorState', () => {
+      const mockEditorState = { isBold: true } as any;
+      const state = createMockState({ editorState: mockEditorState });
+      expect(editorSelectors.editorState(state)).toBe(mockEditorState);
+    });
+  });
+});

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

@@ -1,16 +1,118 @@
+/* eslint-disable sort-keys-fix/sort-keys-fix */
 import type { DocumentStore } from '../../store';
+import type { EditorContentState } from './initialState';
+
+// ===== Active Document Selectors =====
+
+const activeDocumentId = (s: DocumentStore) => s.activeDocumentId;
+
+const activeDocument = (s: DocumentStore): EditorContentState | undefined =>
+  s.activeDocumentId ? s.documents[s.activeDocumentId] : undefined;
 
 const isEditing = (s: DocumentStore) => !!s.activeDocumentId;
 
-const isEditMode = (s: DocumentStore) => s.mode === 'edit';
+// ===== Document by ID Selectors =====
+
+const documentById = (id: string) => (s: DocumentStore) => s.documents[id];
+
+const isDirty = (id: string) => (s: DocumentStore) => s.documents[id]?.isDirty ?? false;
+
+const saveStatus = (id: string) => (s: DocumentStore) => s.documents[id]?.saveStatus ?? 'idle';
+
+const content = (id: string) => (s: DocumentStore) => s.documents[id]?.content ?? '';
+
+const editorData = (id: string) => (s: DocumentStore) => s.documents[id]?.editorData;
+
+const sourceType = (id: string) => (s: DocumentStore) => s.documents[id]?.sourceType;
+
+const lastUpdatedTime = (id: string) => (s: DocumentStore) =>
+  s.documents[id]?.lastUpdatedTime?.toISOString();
+
+// ===== Active Document Convenience Selectors =====
+
+const activeIsDirty = (s: DocumentStore) => {
+  const doc = activeDocument(s);
+  return doc?.isDirty ?? false;
+};
+
+const activeSaveStatus = (s: DocumentStore) => {
+  const doc = activeDocument(s);
+  return doc?.saveStatus ?? 'idle';
+};
+
+const activeContent = (s: DocumentStore) => {
+  const doc = activeDocument(s);
+  return doc?.content ?? '';
+};
+
+const activeEditorData = (s: DocumentStore) => {
+  const doc = activeDocument(s);
+  return doc?.editorData;
+};
 
-const isPreviewMode = (s: DocumentStore) => s.mode === 'preview';
+const activeSourceType = (s: DocumentStore) => {
+  const doc = activeDocument(s);
+  return doc?.sourceType;
+};
+
+const activeLastUpdatedTime = (s: DocumentStore) => {
+  const doc = activeDocument(s);
+  return doc?.lastUpdatedTime;
+};
 
-const canSave = (s: DocumentStore) => s.isDirty && s.saveStatus !== 'saving';
+// ===== Editor State Selectors =====
+
+const editor = (s: DocumentStore) => s.editor;
+
+const editorState = (s: DocumentStore) => s.editorState;
+
+const canSave = (s: DocumentStore) => {
+  const doc = activeDocument(s);
+  return doc?.isDirty && doc?.saveStatus !== 'saving';
+};
+
+// ===== Document List Selectors =====
+
+const documentIds = (s: DocumentStore) => Object.keys(s.documents);
+
+const documentCount = (s: DocumentStore) => Object.keys(s.documents).length;
+
+const hasDocument = (id: string) => (s: DocumentStore) => id in s.documents;
+
+/**
+ * Check if a document is still loading (not yet in the store)
+ */
+const isDocumentLoading = (id: string | undefined) => (s: DocumentStore) => !id || !s.documents[id];
 
 export const editorSelectors = {
+  // Active document
+  activeContent,
+  activeDocument,
+  activeDocumentId,
+  activeEditorData,
+  activeIsDirty,
+  activeLastUpdatedTime,
+  activeSaveStatus,
+  activeSourceType,
+
+  // By ID
+  content,
+  documentById,
+  editorData,
+  hasDocument,
+  isDocumentLoading,
+  isDirty,
+  lastUpdatedTime,
+  saveStatus,
+  sourceType,
+
+  // Editor
   canSave,
-  isEditMode,
+  editor,
+  editorState,
   isEditing,
-  isPreviewMode,
+
+  // List
+  documentCount,
+  documentIds,
 };

package/src/store/document/store.ts

@@ -3,35 +3,34 @@ import { createWithEqualityFn } from 'zustand/traditional';
 import { type StateCreator } from 'zustand/vanilla';
 
 import { createDevtools } from '../middleware/createDevtools';
-import { type EditorAction, type EditorState, createEditorSlice, initialEditorState } from './slices/editor';
+import { type DocumentAction, createDocumentSlice } from './slices/document';
 import {
-  type NotebookAction,
-  type NotebookState,
-  createNotebookSlice,
-  initialNotebookState,
-} from './slices/notebook';
+  type EditorAction,
+  type EditorState,
+  createEditorSlice,
+  initialEditorState,
+} from './slices/editor';
 
-// Combined state type
-export type DocumentState = EditorState & NotebookState;
+// State type
+export type DocumentState = EditorState;
 
-// Combined action type
-export type DocumentAction = EditorAction & NotebookAction;
+// Action type
+export type DocumentStoreAction = DocumentAction & EditorAction;
 
 // Full store type
-export type DocumentStore = DocumentState & DocumentAction;
+export type DocumentStore = DocumentState & DocumentStoreAction;
 
 // Initial state
 const initialState: DocumentState = {
   ...initialEditorState,
-  ...initialNotebookState,
 };
 
 const createStore: StateCreator<DocumentStore, [['zustand/devtools', never]]> = (
   ...parameters
 ) => ({
   ...initialState,
+  ...createDocumentSlice(...parameters),
   ...createEditorSlice(...parameters),
-  ...createNotebookSlice(...parameters),
 });
 
 const devtools = createDevtools('document');