snakemake/report/html_reporter/template/components/abstract_results.js (6)

1-3: Consider renaming or documenting arrayKey for clarity
This utility function is straightforward, but calling it arrayKey may not fully convey its role in creating a unique identifier from label arrays. Consider adding a short docstring or a more descriptive name for easier comprehension.

---

38-53: Add a unique key for each toggle control
When mapping over toggleLabels.entries(), each returned element should have a stable key prop to avoid React’s "missing key" warnings.

return toggleLabels.entries().map(function(entry) {
    let [name, values] = entry;
    return e(
        Toggle,
+       { key: name,
          label: name,
          values: values,
          callback: function(selected) { ... }
        }
    );
});

---

55-62: Optimize setState usage
Assigning data from this.state.data again during every toggle may be redundant if data does not change. You can omit re-storing data or store it outside state to reduce unnecessary re-renders.

toggleCallback(name, selected) {
    let data = this.state.data;
    this.setState(prevState => {
        let toggles = new Map(prevState.toggles);
        toggles.set(name, selected);
-       return { data: data, toggles };
+       return { toggles };
    });
}

---

115-192: Consider optimizing the toggle detection loop for large data
Multiple filter calls on potentially large arrays can degrade performance. A single pass counting approach can be more efficient. Also consider short-circuiting if results is empty.

---

200-216: Add unique keys for rendered headers
When mapping over data.entryLabels to create <th> elements, each should have a key prop to avoid React warnings about missing keys.

data.entryLabels.map(function (label) {
    return e(
        "th",
+       { key: label, className: "text-left p-1 uppercase" },
        label
    )
})

---

218-273: Remove or guard the console.log calls
Repeated console logging in renderEntries can clutter production console output. Either remove these statements or wrap them in a development-check condition to keep logs out of production.

console.log({
-   toggleLabels,
-   entryPath,
-   entryLabels,
});

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

snakemake/report/html_reporter/template/components/abstract_view_manager.js (2)

2-21: Remove unnecessary break statements after return.

The break statements after return are unreachable and should be removed.

Apply this diff to remove unreachable code:

     handleSelectedResult(resultPath) {
         let entry = results[resultPath];
         const mimeType = getResultMimeType(resultPath);

         switch (mimeType) {
             case "image/svg+xml":
             case "image/png":
             case "image/jpeg":
                 return this.handleImg(entry, resultPath);
-                break;
             case "text/html":
                 return this.handleHtml(entry, resultPath);
-                break;
             case "application/pdf":
                 return this.handlePdf(entry, resultPath);
-                break;
             default:
                 return this.handleDefault(entry, resultPath);
         }
     }

---

23-37: Make abstract methods truly abstract using static error messages.

The error messages should indicate that these are abstract methods that must be implemented by subclasses.

Apply this diff to improve error messages:

     handleImg(entry, resultPath) {
-        throw new Error("Unimplemented!");
+        throw new Error("Abstract method 'handleImg' must be implemented by subclass");
     }

     handleHtml(entry, resultPath) {
-        throw new Error("Unimplemented!");
+        throw new Error("Abstract method 'handleHtml' must be implemented by subclass");
     }

     handlePdf(entry, resultPath) {
-        throw new Error("Unimplemented!");
+        throw new Error("Abstract method 'handlePdf' must be implemented by subclass");
     }

     handleDefault(entry, resultPath) {
-        throw new Error("Unimplemented!");
+        throw new Error("Abstract method 'handleDefault' must be implemented by subclass");
     }

snakemake/report/html_reporter/template/components/result_view_button.js (1)

10-62: Reduce code duplication in handler methods.

The handler methods share similar prop creation logic with slight variations. Consider extracting common logic into a helper method.

Apply this diff to reduce duplication:

+    createViewProps(content, entry, resultPath) {
+        let app = this.app;
+        return {
+            href: "#",
+            onClick: function() {
+                app.setView({
+                    content: content,
+                    contentPath: entry.data_uri,
+                    resultPath: resultPath
+                });
+            }
+        };
+    }
+
     handleImg(entry, resultPath) {
-        let app = this.app;
-        let props = {
-            href: "#",
-            onClick: function() {
-                app.setView({
-                    content: "img",
-                    contentPath: entry.data_uri,
-                    resultPath: resultPath
-                });
-            }
-        };
+        let props = this.createViewProps("img", entry, resultPath);
         return this.renderButton(props);
     }

     handleHtml(entry, resultPath) {
-        let app = this.app;
-        let props = {
-            href: "#",
-            onClick: function() {
-                app.setView({
-                    content: "html",
-                    contentPath: entry.data_uri,
-                    resultPath: resultPath
-                });
-            }
-        };
+        let props = this.createViewProps("html", entry, resultPath);
         return this.renderButton(props);
     }

     handlePdf(entry, resultPath) {
-        let app = this.app;
-        let props = {
-            href: "#",
-            onClick: function() {
-                app.setView({
-                    content: "pdf",
-                    contentPath: entry.data_uri,
-                    resultPath: resultPath
-                });
-            }
-        };
+        let props = this.createViewProps("pdf", entry, resultPath);
         return this.renderButton(props);
     }

snakemake/report/html_reporter/template/components/toggle.js (2)

11-16: Remove console.log statement.

The console.log statement should be removed from production code.

 selectValue(selected) {
-    // swap the value
-    console.log(selected);
     this.setState({ value: selected });
     this.props.callback(selected);
 }

---

78-110: Remove commented out code.

The commented out render2 method should be removed as it's not being used.

snakemake/report/html_reporter/template/components/abstract_results.js (1)

92-107: Optimize state updates and improve readability.

The toggleCallback method can be optimized for better readability and performance.

 toggleCallback(name, selected) {
-    let data = this.state.data;
-    let _this = this;
-    this.setState(function (prevState) {
-        let toggles = new Map(prevState.toggles);
-        toggles.set(name, selected);
-        return { data: data, toggles };
-    }, function () {
-        if (_this.state.data.resultPathsToEntryLabels.has(_this.props.app.state.resultPath)) {
-            let toggleLabels = Array.from(data.toggleLabels.keys().map((label) => _this.state.toggles.get(label)));
-            let entryLabels = _this.state.data.resultPathsToEntryLabels.get(_this.props.app.state.resultPath);
-            let targetPath = _this.state.data.entries.get(arrayKey(entryLabels)).get(arrayKey(toggleLabels));
-            _this.toggleViewManager.handleSelectedResult(targetPath);
-        }
-    });
+    this.setState(
+        prevState => {
+            const toggles = new Map(prevState.toggles);
+            toggles.set(name, selected);
+            return { toggles };
+        },
+        () => {
+            const { data, toggles } = this.state;
+            const { resultPath } = this.props.app.state;
+            
+            if (data.resultPathsToEntryLabels.has(resultPath)) {
+                const toggleLabels = Array.from(data.toggleLabels.keys().map(label => toggles.get(label)));
+                const entryLabels = data.resultPathsToEntryLabels.get(resultPath);
+                const targetPath = data.entries.get(arrayKey(entryLabels)).get(arrayKey(toggleLabels));
+                this.toggleViewManager.handleSelectedResult(targetPath);
+            }
+        }
+    );
 }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

snakemake/report/html_reporter/template/components/abstract_view_manager.js (2)

1-1: Enforce abstract class behavior.

Since this is an abstract class, consider adding a constructor that prevents direct instantiation:

 class AbstractViewManager {
+    constructor() {
+        if (this.constructor === AbstractViewManager) {
+            throw new Error('Abstract class "AbstractViewManager" cannot be instantiated directly.');
+        }
+    }

---

20-34: Add JSDoc documentation and improve error messages.

The handler methods need documentation to guide implementers and more descriptive error messages.

+    /**
+     * Handles image type results (svg, png, jpeg)
+     * @param {Object} entry - The result entry
+     * @param {string} resultPath - Path to the result
+     * @returns {void}
+     * @abstract
+     */
     handleImg(entry, resultPath) {
-        throw new Error("Unimplemented!");
+        throw new Error("AbstractViewManager.handleImg() must be implemented by subclass");
     }

+    /**
+     * Handles HTML type results
+     * @param {Object} entry - The result entry
+     * @param {string} resultPath - Path to the result
+     * @returns {void}
+     * @abstract
+     */
     handleHtml(entry, resultPath) {
-        throw new Error("Unimplemented!");
+        throw new Error("AbstractViewManager.handleHtml() must be implemented by subclass");
     }

+    /**
+     * Handles PDF type results
+     * @param {Object} entry - The result entry
+     * @param {string} resultPath - Path to the result
+     * @returns {void}
+     * @abstract
+     */
     handlePdf(entry, resultPath) {
-        throw new Error("Unimplemented!");
+        throw new Error("AbstractViewManager.handlePdf() must be implemented by subclass");
     }

+    /**
+     * Handles results with unsupported MIME types
+     * @param {Object} entry - The result entry
+     * @param {string} resultPath - Path to the result
+     * @returns {void}
+     * @abstract
+     */
     handleDefault(entry, resultPath) {
-        throw new Error("Unimplemented!");
+        throw new Error("AbstractViewManager.handleDefault() must be implemented by subclass");
     }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro