From 44bfdba62b2004807e2dd20b9e7c1593ee22cfb4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Pacanovsk=C3=BD?= <martin.22.pacak@gmail.com>
Date: Thu, 7 May 2026 20:45:41 +0200
Subject: [PATCH 1/4] Make the ability to hide cells in source editing mode

Now you can toggle source editing mode and next to the merge cell button is a new button in a shape of an "eyeball", this allows users to hide or unhide certain cells. Once you leave the source editing mode, the cells will no longer be visible. They can be toggled in the source editing mode.

This feature will help with the future Biblica files to hide unwanted cells containing no text or nothing significant.
---
 .../codexCellEditorMessagehandling.ts         |  60 +++++++++
 .../codexCellEditorProvider.ts                | 120 +++++++++++++++++-
 .../utils/cellUtils.ts                        |   1 +
 types/index.d.ts                              |   9 ++
 .../CodexCellEditor/CellContentDisplay.tsx    |  35 ++++-
 .../src/CodexCellEditor/CellList.tsx          |  14 +-
 6 files changed, 229 insertions(+), 10 deletions(-)

diff --git a/src/providers/codexCellEditorProvider/codexCellEditorMessagehandling.ts b/src/providers/codexCellEditorProvider/codexCellEditorMessagehandling.ts
index 5a5c84ae1..0bd12f297 100644
--- a/src/providers/codexCellEditorProvider/codexCellEditorMessagehandling.ts
+++ b/src/providers/codexCellEditorProvider/codexCellEditorMessagehandling.ts
@@ -1787,6 +1787,66 @@ const messageHandlers: Record<string, (ctx: MessageHandlerContext) => Promise<vo
         }
     },
 
+    toggleCellVisibility: async ({ event, document, webviewPanel, provider, updateWebview }) => {
+        const typedEvent = event as Extract<EditorPostMessages, { command: "toggleCellVisibility" }>;
+        const { cellId, hidden } = typedEvent.content;
+
+        debug("toggleCellVisibility message received for cell:", cellId, "hidden:", hidden);
+
+        try {
+            const currentCellData = document.getCellData(cellId) || {};
+
+            document.updateCellData(cellId, {
+                ...currentCellData,
+                hidden,
+            });
+
+            try {
+                const cellForEdits = document.getCell(cellId);
+                if (cellForEdits) {
+                    if (!cellForEdits.metadata.edits) {
+                        cellForEdits.metadata.edits = [] as any;
+                    }
+                    const ts = Date.now();
+                    let user = "anonymous";
+                    try {
+                        const authApi = await provider.getAuthApi();
+                        const userInfo = await authApi?.getUserInfo();
+                        user = userInfo?.username || "anonymous";
+                    } catch { /* ignore */ }
+                    (cellForEdits.metadata.edits as any[]).push({
+                        editMap: EditMapUtils.metadataNested("data", "hidden"),
+                        value: hidden,
+                        timestamp: ts,
+                        type: EditType.USER_EDIT,
+                        author: user,
+                        validatedBy: [],
+                    });
+                }
+            } catch (e) {
+                console.warn("Failed to record visibility edit entry on cell", e);
+            }
+
+            await document.save(new vscode.CancellationTokenSource().token);
+
+            debug(`Successfully toggled visibility for cell: ${cellId}, hidden: ${hidden}`);
+
+            const workspaceFolder = vscode.workspace.getWorkspaceFolder(document.uri);
+            if (workspaceFolder) {
+                await provider.toggleCellVisibilityInPairedFile(cellId, hidden, document.uri.toString(), workspaceFolder);
+            } else {
+                console.warn("No workspace folder found, skipping paired file visibility toggle");
+            }
+
+            updateWebview();
+        } catch (error) {
+            console.error("Error toggling cell visibility:", cellId, error);
+            vscode.window.showErrorMessage(
+                `Failed to toggle cell visibility: ${error instanceof Error ? error.message : String(error)}`
+            );
+        }
+    },
+
     triggerReindexing: async () => {
         debug("Triggering reindexing after all translations completed");
         await vscode.commands.executeCommand("codex-editor-extension.forceReindex");
diff --git a/src/providers/codexCellEditorProvider/codexCellEditorProvider.ts b/src/providers/codexCellEditorProvider/codexCellEditorProvider.ts
index af5d5ed0c..200ab2931 100755
--- a/src/providers/codexCellEditorProvider/codexCellEditorProvider.ts
+++ b/src/providers/codexCellEditorProvider/codexCellEditorProvider.ts
@@ -2362,6 +2362,7 @@ export class CodexCellEditorProvider implements vscode.CustomEditorProvider<Code
             cellLabel: cell.metadata?.cellLabel,
             merged: cell.metadata?.data?.merged,
             deleted: cell.metadata?.data?.deleted,
+            hidden: cell.metadata?.data?.hidden,
             data: cell.metadata?.data,
             attachments: cell.metadata?.attachments,
             metadata: {
@@ -2394,6 +2395,10 @@ export class CodexCellEditorProvider implements vscode.CustomEditorProvider<Code
                 return;
             }
 
+            if (cell.hidden && !isSourceAndCorrectionEditorMode) {
+                return;
+            }
+
             if (cell.deleted) {
                 return;
             }
@@ -2419,6 +2424,7 @@ export class CodexCellEditorProvider implements vscode.CustomEditorProvider<Code
                 timestamps: cell.timestamps,
                 cellLabel: cell.cellLabel,
                 merged: cell.merged,
+                hidden: cell.hidden,
                 data: cell.data,
                 attachments: cell.attachments,
                 metadata: cell.metadata,
@@ -3063,6 +3069,107 @@ export class CodexCellEditorProvider implements vscode.CustomEditorProvider<Code
         }
     }
 
+    public async toggleCellVisibilityInPairedFile(cellId: string, hidden: boolean, uri: string, workspaceFolder: vscode.WorkspaceFolder) {
+        debug("Toggling cell visibility in paired file:", { cellId, hidden, uri });
+
+        try {
+            const normalizedPath = uri.replace(/\\/g, "/");
+            const baseFileName = path.basename(normalizedPath);
+
+            let targetPath: vscode.Uri;
+            let targetFileName: string;
+            let isSourceToTarget: boolean;
+
+            if (baseFileName.endsWith(".source")) {
+                targetFileName = baseFileName.replace(".source", ".codex");
+                targetPath = vscode.Uri.joinPath(workspaceFolder.uri, "files", "target", targetFileName);
+                isSourceToTarget = true;
+            } else if (baseFileName.endsWith(".codex")) {
+                targetFileName = baseFileName.replace(".codex", ".source");
+                targetPath = vscode.Uri.joinPath(workspaceFolder.uri, ".project", "sourceTexts", targetFileName);
+                isSourceToTarget = false;
+            } else {
+                throw new Error(`Unsupported file type for visibility toggle: ${baseFileName}`);
+            }
+
+            await vscode.commands.executeCommand(
+                "vscode.openWith",
+                targetPath,
+                "codex.cellEditor",
+                { viewColumn: isSourceToTarget ? vscode.ViewColumn.Two : vscode.ViewColumn.One }
+            );
+
+            let targetDocument: CodexCellDocument | undefined;
+            const targetDocumentUri = targetPath.toString();
+
+            for (const [panelUri] of this.webviewPanels.entries()) {
+                if (this.isMatchingFilePair(targetDocumentUri, panelUri)) {
+                    targetDocument = await this.openCustomDocument(
+                        vscode.Uri.parse(panelUri),
+                        {},
+                        new vscode.CancellationTokenSource().token
+                    );
+                    break;
+                }
+            }
+
+            if (!targetDocument) {
+                targetDocument = await this.openCustomDocument(
+                    targetPath,
+                    {},
+                    new vscode.CancellationTokenSource().token
+                );
+            }
+
+            const targetCellData = targetDocument.getCellData(cellId) || {};
+            targetDocument.updateCellData(cellId, {
+                ...targetCellData,
+                hidden,
+            });
+
+            try {
+                const cell = (targetDocument as any).getCell(cellId);
+                if (cell) {
+                    cell.metadata.edits = cell.metadata.edits || [];
+                    cell.metadata.edits.push({
+                        editMap: ["metadata", "data", "hidden"],
+                        value: hidden,
+                        timestamp: Date.now(),
+                        type: "user-edit",
+                        author: "anonymous",
+                        validatedBy: [],
+                    });
+                }
+            } catch (e) {
+                console.warn("Failed to append hidden edit on paired file cell", e);
+            }
+
+            await targetDocument.save(new vscode.CancellationTokenSource().token);
+
+            debug(`Successfully toggled visibility for cell ${cellId} in ${isSourceToTarget ? "target" : "source"} file ${targetFileName}`);
+
+            for (const [panelUri, panel] of this.webviewPanels.entries()) {
+                if (this.isMatchingFilePair(targetDocumentUri, panelUri)) {
+                    const docUri = panelUri;
+                    const rev = this.getDocumentRevision(docUri);
+                    const currentPosition = this.currentMilestoneSubsectionMap.get(docUri);
+                    safePostMessageToPanel(panel, {
+                        type: "refreshCurrentPage",
+                        rev,
+                        milestoneIndex: currentPosition?.milestoneIndex ?? 0,
+                        subsectionIndex: currentPosition?.subsectionIndex ?? 0,
+                    });
+                    break;
+                }
+            }
+        } catch (error) {
+            console.error("Error toggling cell visibility in paired file:", error);
+            vscode.window.showErrorMessage(
+                `Failed to toggle visibility in paired file: ${error instanceof Error ? error.message : String(error)}`
+            );
+        }
+    }
+
     public async getAuthApi() {
         return getAuthApi();
     }
@@ -4185,11 +4292,16 @@ export class CodexCellEditorProvider implements vscode.CustomEditorProvider<Code
             });
         });
 
-        // Refresh all webviews to show/hide merged cells appropriately
+        // Refresh all open webviews so hidden/merged cells are shown or filtered correctly
         for (const [docUri, panel] of this.webviewPanels) {
-            if (this.currentDocument && docUri === this.currentDocument.uri.toString()) {
-                await this.refreshWebview(panel, this.currentDocument);
-            }
+            const rev = this.getDocumentRevision(docUri);
+            const currentPosition = this.currentMilestoneSubsectionMap.get(docUri);
+            safePostMessageToPanel(panel, {
+                type: "refreshCurrentPage",
+                rev,
+                milestoneIndex: currentPosition?.milestoneIndex ?? 0,
+                subsectionIndex: currentPosition?.subsectionIndex ?? 0,
+            });
         }
     }
 
diff --git a/src/providers/codexCellEditorProvider/utils/cellUtils.ts b/src/providers/codexCellEditorProvider/utils/cellUtils.ts
index 8e0ac14be..08705180d 100644
--- a/src/providers/codexCellEditorProvider/utils/cellUtils.ts
+++ b/src/providers/codexCellEditorProvider/utils/cellUtils.ts
@@ -69,6 +69,7 @@ export function convertCellToQuillContent(cell: CustomNotebookCellData): QuillCe
         cellLabel: cell.metadata?.cellLabel,
         merged: cell.metadata?.data?.merged,
         deleted: cell.metadata?.data?.deleted,
+        hidden: cell.metadata?.data?.hidden,
         data: cell.metadata?.data,
         attachments: cell.metadata?.attachments || {},
         metadata: {
diff --git a/types/index.d.ts b/types/index.d.ts
index 5271e2902..c221df7a8 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -550,6 +550,13 @@ export type EditorPostMessages =
         };
     }
     | { command: "toggleCorrectionEditorMode"; }
+    | {
+        command: "toggleCellVisibility";
+        content: {
+            cellId: string;
+            hidden: boolean;
+        };
+    }
     | {
         command: "cancelMerge";
         content: {
@@ -709,6 +716,7 @@ type CodexData = Timestamps & {
     verse?: string;
     merged?: boolean;
     deleted?: boolean;
+    hidden?: boolean;
     originalText?: string;
     globalReferences?: string[]; // Array of cell IDs in original format (e.g., "GEN 1:1") used for header generation
     milestoneIndex?: number | null; // 0-based milestone index for O(1) lookup (null if no milestone)
@@ -939,6 +947,7 @@ interface QuillCellContent {
     cellLabel?: string;
     merged?: boolean;
     deleted?: boolean;
+    hidden?: boolean;
     data?: { [key: string]: any; footnotes?: Footnote[]; };
     attachments?: { [attachmentId: string]: { type: string; isDeleted?: boolean; isMissing?: boolean; url?: string; validatedBy?: ValidationEntry[]; }; };
     metadata?: {
diff --git a/webviews/codex-webviews/src/CodexCellEditor/CellContentDisplay.tsx b/webviews/codex-webviews/src/CodexCellEditor/CellContentDisplay.tsx
index a137cafb0..b38495445 100644
--- a/webviews/codex-webviews/src/CodexCellEditor/CellContentDisplay.tsx
+++ b/webviews/codex-webviews/src/CodexCellEditor/CellContentDisplay.tsx
@@ -341,13 +341,21 @@ const CellContentDisplay: React.FC<CellContentDisplayProps> = React.memo(
         };
 
         const handleCancelMerge = (e: React.MouseEvent) => {
-            e.stopPropagation(); // Prevent the cell click handler from firing
+            e.stopPropagation();
             vscode.postMessage({
                 command: "cancelMerge",
                 content: { cellId: cellIds[0] },
             } as any);
         };
 
+        const handleToggleVisibility = (e: React.MouseEvent) => {
+            e.stopPropagation();
+            vscode.postMessage({
+                command: "toggleCellVisibility",
+                content: { cellId: cellIds[0], hidden: !cell.hidden },
+            } as EditorPostMessages);
+        };
+
         // Handler for merging cell with previous cell
         const handleMergeWithPrevious = (e: React.MouseEvent) => {
             e.stopPropagation(); // Prevent the cell click handler from firing
@@ -656,9 +664,10 @@ const CellContentDisplay: React.FC<CellContentDisplayProps> = React.memo(
                     overflow: "visible",
                     maxWidth: "100%",
                     boxSizing: "border-box",
-                    transition: "border 0.3s ease",
+                    transition: "border 0.3s ease, opacity 0.2s ease",
                     overflowWrap: "break-word",
                     wordWrap: "break-word",
+                    opacity: cell.hidden && isSourceText && isCorrectionEditorMode ? 0.45 : 1,
                     wordBreak: "break-word",
                 }}
             >
@@ -958,6 +967,28 @@ const CellContentDisplay: React.FC<CellContentDisplayProps> = React.memo(
                                             </Button>
                                         </div>
                                     )}
+                                    {isSourceText && isCorrectionEditorMode && (
+                                        <div style={{ flexShrink: 0 }}>
+                                            <Button
+                                                variant="ghost"
+                                                style={{
+                                                    height: "16px",
+                                                    width: "16px",
+                                                    padding: 0,
+                                                    display: "flex",
+                                                    alignItems: "center",
+                                                    justifyContent: "center",
+                                                }}
+                                                onClick={handleToggleVisibility}
+                                                title={cell.hidden ? "Show cell in normal mode" : "Hide cell in normal mode"}
+                                            >
+                                                <i
+                                                    className={`codicon ${cell.hidden ? "codicon-eye-closed" : "codicon-eye"}`}
+                                                    style={{ fontSize: "12px" }}
+                                                />
+                                            </Button>
+                                        </div>
+                                    )}
                                 </div>
                             </div>
                         )}
diff --git a/webviews/codex-webviews/src/CodexCellEditor/CellList.tsx b/webviews/codex-webviews/src/CodexCellEditor/CellList.tsx
index 0990c5cc3..2286956cc 100644
--- a/webviews/codex-webviews/src/CodexCellEditor/CellList.tsx
+++ b/webviews/codex-webviews/src/CodexCellEditor/CellList.tsx
@@ -134,19 +134,24 @@ const CellList: React.FC<CellListProps> = ({
     // State to track unresolved comments count for each cell
     const [cellCommentsCount, setCellCommentsCount] = useState<Map<string, number>>(new Map());
 
-    // Filter out merged cells if we're in correction editor mode for source text
     const filteredTranslationUnits = useMemo(() => {
         let filtered = translationUnits;
 
+        const isSourceCorrectionMode = isSourceText && isCorrectionEditorMode;
+
         // Filter out merged cells if we're in correction editor mode for source text
-        if (isSourceText && isCorrectionEditorMode) {
+        if (isSourceCorrectionMode) {
             filtered = filtered.filter((unit) => {
-                // Check if cell has merged metadata in the data property
                 const cellData = unit.data as any;
                 return !cellData?.merged;
             });
         }
 
+        // Hide hidden cells unless we're in source correction mode (where the eyeball toggle is available)
+        if (!isSourceCorrectionMode) {
+            filtered = filtered.filter((unit) => !unit.hidden);
+        }
+
         // Filter out milestone cells from the view (they remain in JSON)
         filtered = filtered.filter((unit) => unit.cellType !== CodexCellTypes.MILESTONE);
 
@@ -563,7 +568,8 @@ const CellList: React.FC<CellListProps> = ({
                     unit.cellType !== CodexCellTypes.PARATEXT &&
                     unit.cellType !== CodexCellTypes.MILESTONE &&
                     !isChildCell(unit) &&
-                    !unit.merged
+                    !unit.merged &&
+                    !unit.hidden
                 ) {
                     visibleCellCount++;
                 }

From 3f25a18203a5533bedb2225a76bbb24849f17cc1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Pacanovsk=C3=BD?= <martin.22.pacak@gmail.com>
Date: Thu, 7 May 2026 21:21:31 +0200
Subject: [PATCH 2/4] push fix

---
 package-lock.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index e6af9de62..459d3b3db 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
     "name": "codex-editor-extension",
-    "version": "0.26.0",
+    "version": "0.27.0",
     "lockfileVersion": 3,
     "requires": true,
     "packages": {
         "": {
             "name": "codex-editor-extension",
-            "version": "0.26.0",
+            "version": "0.27.0",
             "license": "MIT",
             "dependencies": {
                 "@types/csv-parse": "^1.2.5",

From 2ca6ea305bf3bf8f89cb3e685132109d080153ca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Pacanovsk=C3=BD?= <martin.22.pacak@gmail.com>
Date: Thu, 7 May 2026 21:40:33 +0200
Subject: [PATCH 3/4] push fix

---
 src/test/suite/codexCellEditorProvider.test.ts | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/test/suite/codexCellEditorProvider.test.ts b/src/test/suite/codexCellEditorProvider.test.ts
index 2f7530452..88c500245 100644
--- a/src/test/suite/codexCellEditorProvider.test.ts
+++ b/src/test/suite/codexCellEditorProvider.test.ts
@@ -4820,18 +4820,18 @@ suite("CodexCellEditorProvider Test Suite", () => {
                     "correctionEditorModeChanged should have enabled: true"
                 );
 
-                // Verify that the HTML contains isCorrectionEditorMode: true
-                // The HTML is set during refreshWebview which is called after toggleCorrectionEditorMode
+                // Verify that a refreshCurrentPage message was sent to refresh all panels
+                // toggleCorrectionEditorMode sends refreshCurrentPage (lightweight) instead of
+                // regenerating the full HTML, so the webview re-fetches data at its current position.
+                const refreshPageMessage = postMessageCalls.find(
+                    (msg) => msg.type === "refreshCurrentPage"
+                );
                 assert.ok(
-                    webviewHtml.includes("isCorrectionEditorMode: true"),
-                    "HTML should contain isCorrectionEditorMode: true when source editing mode is on"
+                    refreshPageMessage,
+                    "refreshCurrentPage message should be sent after toggling correction editor mode"
                 );
 
                 // Simulate webview-ready message to trigger pending updates
-                // refreshWebview resets the webview ready state, so scheduled messages won't be sent
-                // until the webview reports ready
-                // Call the actual message callback that was registered during resolveCustomEditor
-                // This will trigger markWebviewReady which executes the scheduled messages
                 if (messageCallback) {
                     await (messageCallback as (message: any) => Promise<void> | void)({ command: 'webviewReady' });
                 }

From 6a084ebaf62cd1481f0df88d40515621b1666a88 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Pacanovsk=C3=BD?= <martin.22.pacak@gmail.com>
Date: Thu, 7 May 2026 21:47:13 +0200
Subject: [PATCH 4/4] push fix

---
 .../codexCellEditorProvider.ts                | 20 +++++++++++--------
 .../suite/codexCellEditorProvider.test.ts     | 16 +++++++--------
 2 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/src/providers/codexCellEditorProvider/codexCellEditorProvider.ts b/src/providers/codexCellEditorProvider/codexCellEditorProvider.ts
index 200ab2931..d386c692c 100755
--- a/src/providers/codexCellEditorProvider/codexCellEditorProvider.ts
+++ b/src/providers/codexCellEditorProvider/codexCellEditorProvider.ts
@@ -4294,14 +4294,18 @@ export class CodexCellEditorProvider implements vscode.CustomEditorProvider<Code
 
         // Refresh all open webviews so hidden/merged cells are shown or filtered correctly
         for (const [docUri, panel] of this.webviewPanels) {
-            const rev = this.getDocumentRevision(docUri);
-            const currentPosition = this.currentMilestoneSubsectionMap.get(docUri);
-            safePostMessageToPanel(panel, {
-                type: "refreshCurrentPage",
-                rev,
-                milestoneIndex: currentPosition?.milestoneIndex ?? 0,
-                subsectionIndex: currentPosition?.subsectionIndex ?? 0,
-            });
+            if (this.currentDocument && docUri === this.currentDocument.uri.toString()) {
+                await this.refreshWebview(panel, this.currentDocument);
+            } else {
+                const rev = this.getDocumentRevision(docUri);
+                const currentPosition = this.currentMilestoneSubsectionMap.get(docUri);
+                safePostMessageToPanel(panel, {
+                    type: "refreshCurrentPage",
+                    rev,
+                    milestoneIndex: currentPosition?.milestoneIndex ?? 0,
+                    subsectionIndex: currentPosition?.subsectionIndex ?? 0,
+                });
+            }
         }
     }
 
diff --git a/src/test/suite/codexCellEditorProvider.test.ts b/src/test/suite/codexCellEditorProvider.test.ts
index 88c500245..2f7530452 100644
--- a/src/test/suite/codexCellEditorProvider.test.ts
+++ b/src/test/suite/codexCellEditorProvider.test.ts
@@ -4820,18 +4820,18 @@ suite("CodexCellEditorProvider Test Suite", () => {
                     "correctionEditorModeChanged should have enabled: true"
                 );
 
-                // Verify that a refreshCurrentPage message was sent to refresh all panels
-                // toggleCorrectionEditorMode sends refreshCurrentPage (lightweight) instead of
-                // regenerating the full HTML, so the webview re-fetches data at its current position.
-                const refreshPageMessage = postMessageCalls.find(
-                    (msg) => msg.type === "refreshCurrentPage"
-                );
+                // Verify that the HTML contains isCorrectionEditorMode: true
+                // The HTML is set during refreshWebview which is called after toggleCorrectionEditorMode
                 assert.ok(
-                    refreshPageMessage,
-                    "refreshCurrentPage message should be sent after toggling correction editor mode"
+                    webviewHtml.includes("isCorrectionEditorMode: true"),
+                    "HTML should contain isCorrectionEditorMode: true when source editing mode is on"
                 );
 
                 // Simulate webview-ready message to trigger pending updates
+                // refreshWebview resets the webview ready state, so scheduled messages won't be sent
+                // until the webview reports ready
+                // Call the actual message callback that was registered during resolveCustomEditor
+                // This will trigger markWebviewReady which executes the scheduled messages
                 if (messageCallback) {
                     await (messageCallback as (message: any) => Promise<void> | void)({ command: 'webviewReady' });
                 }