@salesforcedevs/docs-components 1.17.0-hack-alpha4 → 1.17.0-hack-alpha6

package/src/modules/doc/commentPopup/commentUtils.ts

@@ -0,0 +1,382 @@
+// Utility functions for managing comments in localStorage
+// This file provides helper functions for comment management
+
+export interface Comment {
+    email: string;
+    comment_text: string;
+    timestamp: string;
+}
+
+export interface ApiCommentPayload {
+    branch: string;
+    file_path: string;
+    heading_title: string;
+    start_line: string;
+    end_line: string;
+    comment: {
+        comment_text: string;
+        email: string;
+        timestamp: string;
+    };
+}
+
+export interface ApiCommentResponse {
+    request_branch: string;
+    paths: Array<{
+        path: string;
+        titles: Array<{
+            title: string;
+            comments: Comment[];
+        }>;
+    }>;
+}
+
+const COMMENTS_STORAGE_KEY = "dsc_comments";
+
+/**
+ * Export all comments from localStorage to a JSON file
+ */
+export function exportCommentsToFile(): void {
+    try {
+        const commentsData = localStorage.getItem(COMMENTS_STORAGE_KEY);
+        if (!commentsData) {
+            console.log("No comments found in localStorage");
+            return;
+        }
+
+        const comments = JSON.parse(commentsData);
+        const dataStr = JSON.stringify(comments, null, 2);
+        const dataBlob = new Blob([dataStr], { type: "application/json" });
+
+        const link = document.createElement("a");
+        link.href = URL.createObjectURL(dataBlob);
+        link.download = `dsc-comments-${
+            new Date().toISOString().split("T")[0]
+        }.json`;
+        link.click();
+
+        console.log("Comments exported successfully");
+    } catch (error) {
+        console.error("Error exporting comments:", error);
+    }
+}
+
+/**
+ * Import comments from a JSON file to localStorage
+ */
+export function importCommentsFromFile(file: File): Promise<void> {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+
+        reader.onload = (event) => {
+            try {
+                const content = event.target?.result as string;
+                const comments = JSON.parse(content);
+
+                // Validate the structure
+                if (typeof comments === "object" && comments !== null) {
+                    localStorage.setItem(
+                        COMMENTS_STORAGE_KEY,
+                        JSON.stringify(comments)
+                    );
+                    console.log("Comments imported successfully");
+                    resolve();
+                } else {
+                    reject(new Error("Invalid comments file format"));
+                }
+            } catch (error) {
+                reject(new Error("Failed to parse comments file"));
+            }
+        };
+
+        reader.onerror = () => {
+            reject(new Error("Failed to read file"));
+        };
+
+        reader.readAsText(file);
+    });
+}
+
+/**
+ * Get all comments from localStorage
+ */
+export function getAllComments(): Record<string, Comment[]> {
+    try {
+        const commentsData = localStorage.getItem(COMMENTS_STORAGE_KEY);
+        return commentsData ? JSON.parse(commentsData) : {};
+    } catch (error) {
+        console.error("Error reading comments from localStorage:", error);
+        return {};
+    }
+}
+
+/**
+ * Get comments for a specific location
+ */
+export function getCommentsForLocation(
+    branch: string,
+    filePath: string,
+    headingTitle: string
+): Comment[] {
+    try {
+        const allComments = getAllComments();
+        const commentKey = `${branch}_${filePath}_${headingTitle}`;
+        return allComments[commentKey] || [];
+    } catch (error) {
+        console.error("Error getting comments for location:", error);
+        return [];
+    }
+}
+
+/**
+ * Get all comments for a specific branch (simulating API response format)
+ */
+export function getCommentsForBranch(branch: string): ApiCommentResponse {
+    try {
+        const allComments = getAllComments();
+        const branchComments: ApiCommentResponse = {
+            request_branch: branch,
+            paths: []
+        };
+
+        // Group comments by file path and title
+        const pathMap = new Map<string, Map<string, Comment[]>>();
+
+        Object.keys(allComments).forEach((key) => {
+            const [commentBranch, filePath, headingTitle] = key.split("_", 3);
+
+            if (commentBranch === branch) {
+                if (!pathMap.has(filePath)) {
+                    pathMap.set(filePath, new Map());
+                }
+
+                const titleMap = pathMap.get(filePath)!;
+                if (!titleMap.has(headingTitle)) {
+                    titleMap.set(headingTitle, []);
+                }
+
+                titleMap.get(headingTitle)!.push(...allComments[key]);
+            }
+        });
+
+        // Convert to API response format
+        pathMap.forEach((titleMap, filePath) => {
+            const titles: Array<{ title: string; comments: Comment[] }> = [];
+
+            titleMap.forEach((comments, title) => {
+                titles.push({
+                    title,
+                    comments: comments.sort(
+                        (a, b) =>
+                            new Date(b.timestamp).getTime() -
+                            new Date(a.timestamp).getTime()
+                    )
+                });
+            });
+
+            branchComments.paths.push({
+                path: filePath,
+                titles
+            });
+        });
+
+        return branchComments;
+    } catch (error) {
+        console.error("Error getting comments for branch:", error);
+        return {
+            request_branch: branch,
+            paths: []
+        };
+    }
+}
+
+/**
+ * Clear all comments from localStorage
+ */
+export function clearAllComments(): void {
+    try {
+        localStorage.removeItem(COMMENTS_STORAGE_KEY);
+        console.log("All comments cleared from localStorage");
+    } catch (error) {
+        console.error("Error clearing comments:", error);
+    }
+}
+
+/**
+ * Get statistics about stored comments
+ */
+export function getCommentsStats(): {
+    totalLocations: number;
+    totalComments: number;
+    branches: string[];
+    locations: Array<{
+        key: string;
+        branch: string;
+        filePath: string;
+        headingTitle: string;
+        commentCount: number;
+        lastComment?: string;
+    }>;
+} {
+    try {
+        const allComments = getAllComments();
+        const locations = Object.keys(allComments);
+        let totalComments = 0;
+        const branches = new Set<string>();
+
+        const locationStats = locations.map((key) => {
+            const [branch, filePath, headingTitle] = key.split("_", 3);
+            const comments = allComments[key];
+            totalComments += comments.length;
+            branches.add(branch);
+
+            return {
+                key,
+                branch,
+                filePath,
+                headingTitle,
+                commentCount: comments.length,
+                lastComment:
+                    comments.length > 0
+                        ? comments[comments.length - 1].timestamp
+                        : undefined
+            };
+        });
+
+        return {
+            totalLocations: locations.length,
+            totalComments,
+            branches: Array.from(branches),
+            locations: locationStats
+        };
+    } catch (error) {
+        console.error("Error getting comments stats:", error);
+        return {
+            totalLocations: 0,
+            totalComments: 0,
+            branches: [],
+            locations: []
+        };
+    }
+}
+
+/**
+ * Convert localStorage comments to API format for backend migration
+ */
+export function convertToApiFormat(): Array<{
+    branch: string;
+    file_path: string;
+    heading_title: string;
+    start_line: string;
+    end_line: string;
+    comments: Comment[];
+}> {
+    try {
+        const allComments = getAllComments();
+        const apiFormat: Array<{
+            branch: string;
+            file_path: string;
+            heading_title: string;
+            start_line: string;
+            end_line: string;
+            comments: Comment[];
+        }> = [];
+
+        Object.keys(allComments).forEach((key) => {
+            const [branch, file_path, heading_title] = key.split("_", 3);
+            if (branch && file_path && heading_title) {
+                apiFormat.push({
+                    branch,
+                    file_path,
+                    heading_title,
+                    start_line: "",
+                    end_line: "",
+                    comments: allComments[key]
+                });
+            }
+        });
+
+        return apiFormat;
+    } catch (error) {
+        console.error("Error converting to API format:", error);
+        return [];
+    }
+}
+
+/**
+ * Add a comment to localStorage
+ */
+export function addComment(payload: ApiCommentPayload): void {
+    try {
+        const existingData = localStorage.getItem(COMMENTS_STORAGE_KEY);
+        const allComments = existingData ? JSON.parse(existingData) : {};
+
+        const commentKey = `${payload.branch}_${payload.file_path}_${payload.heading_title}`;
+
+        if (!allComments[commentKey]) {
+            allComments[commentKey] = [];
+        }
+
+        allComments[commentKey].push(payload.comment);
+        localStorage.setItem(COMMENTS_STORAGE_KEY, JSON.stringify(allComments));
+
+        console.log("Comment added successfully");
+    } catch (error) {
+        console.error("Error adding comment:", error);
+        throw error;
+    }
+}
+
+/**
+ * Simulate API call to get comments for a branch
+ */
+export async function fetchCommentsForBranch(
+    branch: string
+): Promise<ApiCommentResponse> {
+    try {
+        // Simulate API delay
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        return getCommentsForBranch(branch);
+    } catch (error) {
+        console.error("Error fetching comments for branch:", error);
+        throw error;
+    }
+}
+
+/**
+ * Extract comments for specific file path and heading title from API response
+ */
+export function extractCommentsFromApiResponse(
+    data: ApiCommentResponse,
+    filePath: string,
+    headingTitle: string
+): Comment[] {
+    try {
+        // Find the path that matches our file path
+        const matchingPath = data.paths.find((path) => path.path === filePath);
+
+        if (!matchingPath) {
+            console.log(`No comments found for file path: ${filePath}`);
+            return [];
+        }
+
+        // Find the title that matches our heading title
+        const matchingTitle = matchingPath.titles.find(
+            (title) => title.title === headingTitle
+        );
+
+        if (!matchingTitle) {
+            console.log(`No comments found for heading title: ${headingTitle}`);
+            return [];
+        }
+
+        console.log(
+            `Found ${matchingTitle.comments.length} comments for ${filePath} - ${headingTitle}`
+        );
+        return matchingTitle.comments;
+    } catch (error) {
+        console.error("Error extracting comments from API response:", error);
+        return [];
+    }
+}