@altimateai/ui-components 0.0.79 → 0.0.80

package/dist/582.js

@@ -0,0 +1,1299 @@
+import "./rslib-runtime.js";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { createContext, lazy, useCallback as external_react_useCallback, useContext, useEffect as external_react_useEffect, useMemo, useReducer, useRef, useState as external_react_useState } from "react";
+import web_highlighter from "web-highlighter";
+import { createSlice } from "@reduxjs/toolkit";
+import { AnimatePresence } from "framer-motion";
+import { Button, Card, CardContent, CardTitle, CodeBlock, IconButton, LoadingButton, Stack } from "@altimateai/lego";
+import { createPortal } from "react-dom";
+import { Mention, MentionsInput } from "react-mentions";
+import dayjs from "dayjs";
+var types_ConversationSources = /*#__PURE__*/ function(ConversationSources) {
+    ConversationSources["DBT_DOCS"] = "dbt-docs";
+    ConversationSources["DOCUMENTATION_EDITOR"] = "documentation-editor";
+    ConversationSources["SAAS"] = "saas";
+    return ConversationSources;
+}({});
+const getResourceTypeAndPageFromUrlHash = ()=>{
+    const hashParts = window.location.hash?.split("#")[1]?.replace("!/", "")?.split("/");
+    return {
+        name: hashParts?.[1],
+        resourceType: hashParts?.[0]
+    };
+};
+const ALTIMATE_DISPLAY_ELEMENT_ID_PREFIX = "altimate-display-";
+const HIGHLIGHT_CLASS = `${ALTIMATE_DISPLAY_ELEMENT_ID_PREFIX}-highlight`;
+const HIGHLIGHT_HOVER_CLASS = `${ALTIMATE_DISPLAY_ELEMENT_ID_PREFIX}-highlight-hover`;
+const ACTIVE_HIGHLIGHT_CLASS = `${ALTIMATE_DISPLAY_ELEMENT_ID_PREFIX}-active-highlight`;
+const highlighter = new web_highlighter({
+    style: {
+        className: HIGHLIGHT_CLASS
+    }
+});
+const activeHighlighter = new web_highlighter({
+    style: {
+        className: ACTIVE_HIGHLIGHT_CLASS
+    }
+});
+const selectedNodesHook = (_id, selectedNodes)=>selectedNodes.filter((node)=>node.$node.nodeValue?.trim() !== "");
+const serializeRestoreHook = (_hs, start, end)=>{
+    const startNode = start;
+    const endNode = end;
+    const nodeNameBlacklist = [
+        "BR",
+        "HR"
+    ];
+    if (nodeNameBlacklist.includes(startNode.$node.nodeName) && startNode.$node.parentNode) startNode.$node = startNode.$node.parentNode;
+    if (nodeNameBlacklist.includes(endNode.$node.nodeName) && endNode.$node.parentNode) endNode.$node = endNode.$node.parentNode;
+    return [
+        startNode,
+        endNode
+    ];
+};
+highlighter.hooks.Render.SelectedNodes.tap(selectedNodesHook);
+highlighter.hooks.Serialize.Restore.tap(serializeRestoreHook);
+activeHighlighter.hooks.Render.SelectedNodes.tap(selectedNodesHook);
+activeHighlighter.hooks.Serialize.Restore.tap(serializeRestoreHook);
+highlighter.on("selection:hover", ({ id })=>{
+    highlighter.addClass(HIGHLIGHT_HOVER_CLASS, id);
+}).on("selection:hover-out", ({ id })=>{
+    highlighter.removeClass(HIGHLIGHT_HOVER_CLASS, id);
+});
+const getHighlightSourceFromPostAnchor = (post)=>{
+    if (!post.meta?.highlight) return null;
+    return JSON.parse(post.meta?.highlight);
+};
+const removeHighlight = (anchor)=>{
+    const hs = getHighlightSourceFromPostAnchor(anchor);
+    if (!hs) return;
+    highlighter.remove(hs.id);
+    activeHighlighter.remove(hs.id);
+};
+const getCodeBlockElementInPage = ()=>{
+    const modelParts = getModelPartsFromLocationHash();
+    const codeSection = modelParts?.[1] === "analysis" ? document.getElementById("sql") : document.getElementById("code");
+    return codeSection?.parentElement?.querySelector("code-block")?.querySelector("code.ng-binding.highlight");
+};
+const getModelPartsFromLocationHash = ()=>{
+    const hashParts = window.location.hash.split("#");
+    return hashParts.find((text)=>text.startsWith("!"))?.split("/");
+};
+const getModelDescriptionElement = ()=>document.querySelector('[marked="model.description"]');
+const getConversationGroupTargetElement = (meta)=>{
+    if (!meta.field) return getCodeBlockElementInPage();
+    if (meta.column) {
+        const columnDescriptionTd = Array.from(document.querySelectorAll("column-details tr:not(.ng-hide) td:first-child")).find((el)=>el.innerText === meta.column)?.parentElement?.querySelector("td:nth-child(3)");
+        return columnDescriptionTd;
+    }
+    return getModelDescriptionElement()?.firstChild;
+};
+const getField = (element)=>{
+    if ("model.description" === element.getAttribute("marked")) return "description";
+};
+const getSelectionRange = (field, target, highlightedText, selectionEnd, selectionStart)=>{
+    if ("description" === field) return {
+        start: 0,
+        end: 0,
+        x: 0,
+        y: 0
+    };
+    const lineNumbers = target.querySelectorAll(".line-numbers-rows > span");
+    const selectedLines = highlightedText.split("\n");
+    const endY = Math.max(selectionStart.y, selectionEnd.y);
+    const end = Array.from(lineNumbers).findIndex((node)=>{
+        const { height, y } = node.getBoundingClientRect();
+        return endY >= y && endY <= y + height;
+    });
+    const endLineNumberElement = lineNumbers[end];
+    const start = end - selectedLines.length + 1;
+    console.log("start and end lines found", start, end);
+    return {
+        x: endLineNumberElement.offsetLeft,
+        y: endLineNumberElement.offsetTop + endLineNumberElement.offsetHeight / 2,
+        start,
+        end
+    };
+};
+const getSelectionAllowedElements = ()=>[
+        getCodeBlockElementInPage()?.parentElement,
+        getModelDescriptionElement()
+    ];
+const initialState = {
+    users: {},
+    isRightPanelOpen: false,
+    selectedConversationId: void 0,
+    conversations: {},
+    conversationsLoadingState: 1,
+    newConversation: void 0,
+    shareId: void 0,
+    docsAppRendered: false,
+    currentPage: getResourceTypeAndPageFromUrlHash(),
+    codeblockLoaded: false,
+    source: types_ConversationSources.DBT_DOCS,
+    manifest: {}
+};
+const conversationsSlice = createSlice({
+    name: "appState",
+    initialState: initialState,
+    reducers: {
+        setDocsAppRendered: (state, action)=>{
+            state.docsAppRendered = action.payload;
+        },
+        setManifest: (state, action)=>{
+            state.manifest = action.payload;
+        },
+        updateCurrentPage: (state, action)=>{
+            state.currentPage = action.payload;
+        },
+        setConversationSource: (state, action)=>{
+            state.source = action.payload;
+        },
+        updateCodeblockLoaded: (state, action)=>{
+            state.codeblockLoaded = action.payload;
+        },
+        setShareId: (state, action)=>{
+            state.shareId = action.payload;
+        },
+        setCurrentUserId: (state, action)=>{
+            state.currentUserId = action.payload;
+        },
+        setConversationsLoadingState: (state, action)=>{
+            state.conversationsLoadingState = action.payload;
+        },
+        refetchConversations: (state)=>{
+            state.conversationsLoadingState = 1;
+        },
+        setUsers: (state, action)=>{
+            if (!action.payload?.length) return state;
+            return {
+                ...state,
+                users: action.payload.reduce((acc, user)=>{
+                    acc[user.id] = user;
+                    return acc;
+                }, {})
+            };
+        },
+        updateRightPanelState: (state, action)=>{
+            state.isRightPanelOpen = action.payload;
+        },
+        updateSelectedConversationId: (state, action)=>{
+            state.selectedConversationId = action.payload;
+        },
+        upsertConversation: (state, action)=>{
+            state.conversations = {
+                ...state.conversations,
+                [action.payload.conversation_group_id]: {
+                    ...state.conversations[action.payload.conversation_group_id],
+                    ...action.payload
+                }
+            };
+        },
+        resolveConversationGroup: (state, { payload: { conversationGroupId } })=>{
+            if (state.conversations[conversationGroupId]) delete state.conversations[conversationGroupId];
+        },
+        updateNewConversation: (state, action)=>{
+            const updated = {
+                ...action.payload
+            };
+            if (!updated.meta) return void console.log("Invalid meta");
+            const modelParts = getModelPartsFromLocationHash();
+            if (!modelParts || modelParts.length < 3) return void console.error("Unable to find model parts", modelParts);
+            console.log("model parts found", modelParts);
+            updated.meta.uniqueId = modelParts[2];
+            updated.meta.resource_type = modelParts[1];
+            if (!updated.meta.range) updated.meta.range = {
+                end: {
+                    line: 0,
+                    character: 0
+                },
+                start: {
+                    line: 0,
+                    character: 0
+                }
+            };
+            if (updated.meta.uniqueId) {
+                const node = state.manifest.nodes?.[updated.meta.uniqueId] || state.manifest.macros?.[updated.meta.uniqueId];
+                updated.meta.filePath = node?.original_file_path || "";
+            }
+            state.newConversation = updated;
+        },
+        resetNewConversation: (state)=>{
+            state.newConversation = void 0;
+        },
+        setConversations: (state, action)=>{
+            if (!action.payload) return;
+            state.conversations = action.payload.reduce((acc, conversation)=>{
+                acc[conversation.conversation_group_id] = conversation;
+                return acc;
+            }, {});
+            state.selectedConversationId = state.selectedConversationId || action.payload[0].conversation_group_id;
+        }
+    }
+});
+const { setCurrentUserId: setCurrentUserId, setShareId: setShareId, updateSelectedConversationId: updateSelectedConversationId, updateRightPanelState: updateRightPanelState, setUsers: setUsers, setConversations: setConversations, resetNewConversation: resetNewConversation, updateNewConversation: updateNewConversation, upsertConversation: upsertConversation, setDocsAppRendered: setDocsAppRendered, updateCurrentPage: updateCurrentPage, updateCodeblockLoaded: updateCodeblockLoaded, resolveConversationGroup: resolveConversationGroup, setConversationsLoadingState: setConversationsLoadingState, refetchConversations: refetchConversations, setConversationSource: setConversationSource, setManifest: setManifest } = conversationsSlice.actions;
+const DbtDocsReducer = conversationsSlice;
+const DbtDocsCollaborationContext = /*#__PURE__*/ createContext({
+    state: DbtDocsReducer.getInitialState(),
+    dispatch: ()=>null,
+    getValue: ()=>null
+});
+const DbtDocsCollaborationProvider = ({ children, shareId, userId, conversationGroupId, source })=>{
+    const [state, dispatch] = useReducer(DbtDocsReducer.reducer, {
+        ...DbtDocsReducer.getInitialState(),
+        shareId,
+        currentUserId: userId,
+        selectedConversationId: conversationGroupId,
+        isRightPanelOpen: Boolean(conversationGroupId),
+        source
+    });
+    const getValue = external_react_useCallback((callback)=>callback(state), [
+        state
+    ]);
+    const values = useMemo(()=>({
+            state,
+            dispatch,
+            getValue
+        }), [
+        state,
+        dispatch,
+        getValue
+    ]);
+    return /*#__PURE__*/ jsx(DbtDocsCollaborationContext.Provider, {
+        value: values,
+        children: children
+    });
+};
+const collaboration_DbtDocsCollaborationProvider = DbtDocsCollaborationProvider;
+const useDbtDocsCollaborationContext = ()=>useContext(DbtDocsCollaborationContext);
+const useDbtDocsCollaborationSelector = (callback)=>{
+    const { getValue } = useContext(DbtDocsCollaborationContext);
+    return getValue(callback);
+};
+const useDbtDocsCollaborationDispatch = ()=>{
+    const { dispatch } = useContext(DbtDocsCollaborationContext);
+    return dispatch;
+};
+import "./static/svg/brackets.svg";
+import "./static/svg/half-circle.svg";
+import "./static/svg/case-sensitive.svg";
+import "./static/svg/split-horizontal.svg";
+const Icon = ({ icon, className = "", ...rest })=>/*#__PURE__*/ jsx("i", {
+        className: `${className} codicon codicon-${icon}`,
+        ...rest
+    });
+const AddIcon = (props)=>/*#__PURE__*/ jsx(Icon, {
+        icon: "add",
+        ...props
+    });
+const CommentUnresolvedIcon = (props)=>/*#__PURE__*/ jsx(Icon, {
+        icon: "comment-unresolved",
+        ...props
+    });
+const CheckNoOutlineIcon = (props)=>/*#__PURE__*/ jsx(Icon, {
+        icon: "check",
+        ...props
+    });
+const AskIcon = (props)=>/*#__PURE__*/ jsx(Icon, {
+        icon: "send",
+        ...props
+    });
+const CloseIcon = (props)=>/*#__PURE__*/ jsx(Icon, {
+        icon: "close",
+        ...props
+    });
+const HighlightAnchor = ({ pos, onAddComment })=>/*#__PURE__*/ createPortal(/*#__PURE__*/ jsx(AnimatePresence, {
+        children: pos && /*#__PURE__*/ jsx(Button, {
+            onClick: onAddComment,
+            id: `${ALTIMATE_DISPLAY_ELEMENT_ID_PREFIX}-highlight`,
+            style: {
+                position: "absolute",
+                top: pos.y,
+                left: pos.x,
+                zIndex: 1054,
+                cursor: "pointer",
+                background: "#007AFF",
+                width: 26,
+                height: 26,
+                borderRadius: "100%",
+                boxShadow: "none",
+                border: "none",
+                display: "flex",
+                justifyContent: "center",
+                alignItems: "center",
+                fontSize: "13px",
+                fontWeight: "bold",
+                color: "#fff",
+                padding: 0
+            },
+            children: /*#__PURE__*/ jsx(AddIcon, {})
+        })
+    }), pos.element.parentElement);
+const collaboration_HighlightAnchor = HighlightAnchor;
+const ShowConversationsButton = ()=>{
+    const { state: { isRightPanelOpen } } = useDbtDocsCollaborationContext();
+    const dispatch = useDbtDocsCollaborationDispatch();
+    const toggleRightPanel = ()=>{
+        dispatch(updateRightPanelState(!isRightPanelOpen));
+    };
+    return /*#__PURE__*/ jsx(Button, {
+        onClick: toggleRightPanel,
+        children: isRightPanelOpen ? "Hide conversations" : "Show conversations"
+    });
+};
+const collaboration_ShowConversationsButton = ShowConversationsButton;
+const ApiHelper = {
+    get: async (_url, _data, _request)=>({}),
+    post: async (_url, _data, _request)=>({})
+};
+const getDbtDocsShareDetailsById = (shareId)=>ApiHelper.get(`dbt/dbt_docs_share/${shareId}`);
+const createNewConversationGroup = (shareId, data, source)=>ApiHelper.post(`dbt/dbt_docs_share/${shareId}/conversation_group`, {
+        ...data,
+        telemetry: {
+            eventName: "dbtCollaboration:create",
+            properties: {
+                source
+            }
+        }
+    });
+const addConversationToGroup = (shareId, conversationGroupId, data, source)=>ApiHelper.post(`dbt/dbt_docs_share/${shareId}/conversation_group/${conversationGroupId}/conversation`, {
+        ...data,
+        telemetry: {
+            eventName: "dbtCollaboration:reply",
+            properties: {
+                source
+            }
+        }
+    });
+const getConversationsByShareId = (shareId)=>ApiHelper.get(`dbt/dbt_docs_share/${shareId}/conversations`);
+const getUserList = (company)=>ApiHelper.get("users/chat", {
+        company
+    });
+const api_resolveConversationGroup = (shareId, conversationGroupId, source)=>ApiHelper.post(`dbt/dbt_docs_share/${shareId}/conversation_group/${conversationGroupId}/resolve`, {
+        resolved: true,
+        telemetry: {
+            eventName: "dbtCollaboration:resolve",
+            properties: {
+                source
+            }
+        }
+    });
+const useDbtDocsCollaboration = ()=>{
+    const shareId = useDbtDocsCollaborationSelector((state)=>state.shareId);
+    const [shareDetails, setShareDetails] = external_react_useState(null);
+    const [loading, setLoading] = external_react_useState(false);
+    const dispatch = useDbtDocsCollaborationDispatch();
+    external_react_useEffect(()=>{
+        if (!shareDetails?.manifest_presigned_url) return;
+        fetch(shareDetails.manifest_presigned_url).then((response)=>response.json()).then((response)=>{
+            dispatch(setManifest(response));
+        }).catch((error)=>console.error("error loading manifest", error, shareDetails.manifest_presigned_url));
+    }, [
+        dispatch,
+        shareDetails?.manifest_presigned_url
+    ]);
+    const loadDetails = external_react_useCallback(async ()=>{
+        if (!shareId) return;
+        setLoading(true);
+        const response = await getDbtDocsShareDetailsById(shareId);
+        if (response) {
+            setShareDetails(response);
+            const leftArrowBtn = document.getElementById("collapse-sidebar");
+            leftArrowBtn?.click();
+        }
+        setLoading(false);
+    }, [
+        shareId
+    ]);
+    external_react_useEffect(()=>{
+        if (!shareId || shareDetails || loading) return;
+        loadDetails();
+    }, [
+        shareId,
+        shareDetails,
+        loadDetails,
+        loading
+    ]);
+    return {
+        shareDetails,
+        loading
+    };
+};
+const collaboration_useDbtDocsCollaboration = useDbtDocsCollaboration;
+const useHighlight = ()=>{
+    const selectedConversation = useDbtDocsCollaborationSelector((state)=>state.selectedConversationId ? state.conversations[state.selectedConversationId] : null);
+    const isDocsAppRendered = useDbtDocsCollaborationSelector((state)=>state.docsAppRendered);
+    const newConversation = useDbtDocsCollaborationSelector((state)=>state.newConversation);
+    const dispatch = useDbtDocsCollaborationDispatch();
+    const [highlightPostData, setHighlightPostData] = external_react_useState(null);
+    const [pos, setPos] = external_react_useState(null);
+    external_react_useEffect(()=>{
+        if (newConversation) {
+            setHighlightPostData(null);
+            setPos(null);
+        }
+    }, [
+        newConversation
+    ]);
+    const resetHighlights = external_react_useCallback(()=>{
+        console.log("resetHighlights");
+        if (highlightPostData) removeHighlight(highlightPostData);
+        setPos(null);
+        setHighlightPostData(null);
+    }, [
+        highlightPostData
+    ]);
+    external_react_useEffect(()=>{
+        if (!selectedConversation || !isDocsAppRendered) return;
+        if (selectedConversation.meta.resource_type && selectedConversation.meta.uniqueId) window.location.hash = `#!/${selectedConversation.meta.resource_type}/${selectedConversation.meta.uniqueId}`;
+    }, [
+        selectedConversation,
+        isDocsAppRendered,
+        dispatch
+    ]);
+    const onSelectionEnd = (event)=>{
+        const target = event.target;
+        const field = getField(target);
+        const { end: selectionEnd, start: selectionStart } = event.detail.selectionRange;
+        const selection = document.getSelection();
+        if (!selection || !selection.rangeCount) {
+            resetHighlights();
+            return null;
+        }
+        const range = selection.getRangeAt(0);
+        const highlightedText = range.toString();
+        const code = target?.innerText;
+        if (!highlightedText || !code) return;
+        const { end, start, x, y } = getSelectionRange(field, target, highlightedText, selectionEnd, selectionStart);
+        console.log("selection range", end, start, x, y);
+        const data = {
+            meta: {
+                filePath: "",
+                field,
+                highlight: highlightedText,
+                range: {
+                    end: {
+                        line: end,
+                        character: 0
+                    },
+                    start: {
+                        line: start,
+                        character: 0
+                    }
+                }
+            }
+        };
+        dispatch(resetNewConversation());
+        setPos({
+            x,
+            y,
+            element: target
+        });
+        document.body.addEventListener("click", resetHighlights, {
+            once: true
+        });
+        setHighlightPostData(data);
+    };
+    return {
+        getHighlightedSelectionData: ()=>highlightPostData,
+        pos,
+        onSelectionEnd
+    };
+};
+const collaboration_useHighlight = useHighlight;
+const ConversationHighlighter = ({ conversationGroup })=>{
+    const selectedConversationId = useDbtDocsCollaborationSelector((state)=>state.selectedConversationId);
+    const dispatch = useDbtDocsCollaborationDispatch();
+    const highlightRef = useRef(null);
+    const target = useMemo(()=>getConversationGroupTargetElement(conversationGroup.meta), [
+        conversationGroup.meta
+    ]);
+    const handleClick = ()=>{
+        dispatch(updateSelectedConversationId(conversationGroup.conversation_group_id));
+    };
+    const position = useMemo(()=>{
+        if (!target) return;
+        if ("description" === conversationGroup.meta.field) return {
+            top: 0,
+            bottom: target.offsetHeight
+        };
+        let top = 0;
+        let bottom = 0;
+        for(let i = conversationGroup.meta.range.start.line; i <= conversationGroup.meta.range.end.line; i++){
+            const lineNumber = target.querySelector(`.line-numbers-rows > span:nth-child(${i + 1})`);
+            if (lineNumber) {
+                if (i === conversationGroup.meta.range.start.line) top = lineNumber.offsetTop + 15;
+                if (i === conversationGroup.meta.range.end.line) bottom = lineNumber.offsetTop + lineNumber.offsetHeight;
+            }
+        }
+        return {
+            top,
+            bottom
+        };
+    }, [
+        target,
+        conversationGroup.meta.field,
+        conversationGroup.meta.range.start.line,
+        conversationGroup.meta.range.end.line
+    ]);
+    external_react_useEffect(()=>{
+        if (selectedConversationId !== conversationGroup.conversation_group_id) return;
+        highlightRef.current?.scrollIntoView({
+            behavior: "smooth",
+            block: "center"
+        });
+    }, [
+        conversationGroup.conversation_group_id,
+        selectedConversationId
+    ]);
+    if (!position || !target?.parentElement) return null;
+    return /*#__PURE__*/ createPortal(/*#__PURE__*/ jsx("div", {
+        ref: highlightRef,
+        className: `altimate-highlighter ${selectedConversationId === conversationGroup.conversation_group_id ? "active" : ""}`,
+        style: {
+            top: position.top,
+            height: position.bottom - position.top
+        },
+        onClick: handleClick,
+        children: /*#__PURE__*/ jsx(CommentUnresolvedIcon, {})
+    }), target.parentElement);
+};
+const collaboration_ConversationHighlighter = ConversationHighlighter;
+const ConversationsHighlighter = ()=>{
+    const conversationGroups = useDbtDocsCollaborationSelector((state)=>Object.values(state.conversations || {}));
+    const codeblockLoaded = useDbtDocsCollaborationSelector((state)=>state.codeblockLoaded);
+    const currentPage = useDbtDocsCollaborationSelector((state)=>state.currentPage);
+    const conversationsInCurrentPage = conversationGroups?.filter((conversationGroup)=>conversationGroup.meta.resource_type === currentPage.resourceType && conversationGroup.meta.uniqueId === currentPage.name);
+    if (!conversationsInCurrentPage?.length || !codeblockLoaded) return null;
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: conversationsInCurrentPage.map((conversationGroup)=>/*#__PURE__*/ jsx(collaboration_ConversationHighlighter, {
+                conversationGroup: conversationGroup
+            }, conversationGroup.conversation_group_id))
+    });
+};
+const collaboration_ConversationsHighlighter = ConversationsHighlighter;
+const styles_module = {
+    dbtDocs: "dbtDocs-fMtUb6",
+    hotspotButton: "hotspotButton-dTVyi_",
+    pulse: "pulse-b0fWZW",
+    conversationRightPanelCloseButton: "conversationRightPanelCloseButton-UrkRMu",
+    conversationRightPanel: "conversationRightPanel-sztyiY",
+    newConversationForm: "newConversationForm-K9GEep",
+    highlightText: "highlightText-LYVCe1",
+    conversationInputForm: "conversationInputForm-SdxXJT",
+    conversationGroup: "conversationGroup-hiNZQ0",
+    replyForm: "replyForm-qvHtmB",
+    resolveButton: "resolveButton-roENjF"
+};
+const user_styles_module = {
+    profileImage: "profileImage-tkto2K"
+};
+const ProfileImageByUser = ({ user })=>/*#__PURE__*/ jsx("div", {
+        className: user_styles_module.profileImage,
+        children: user?.first_name?.[0] || ""
+    });
+const user_ProfileImageByUser = ProfileImageByUser;
+const StyleMentionInput = {
+    "&multiLine": {
+        minHeight: "40px"
+    },
+    input: {
+        border: "none",
+        outline: "none",
+        fontWeight: "500",
+        fontSize: "15px",
+        color: "rgba(0, 5, 15, 0.85)"
+    },
+    suggestions: {
+        backgroundColor: "var(--background--01)",
+        border: "1px solid rgba(0,0,0,0.1)",
+        borderRadius: "8px",
+        padding: "5px",
+        boxShadow: "0px 0px 10px rgba(0,0,0,0.1)",
+        minWidth: "150px",
+        maxHeight: "200px",
+        overflowY: "auto",
+        item: {
+            fontSize: "15px",
+            padding: "4px 11px 4px 11px",
+            borderRadius: "4px",
+            fontWeight: "500",
+            "&focused": {
+                backgroundColor: "var(--background--04)"
+            }
+        }
+    }
+};
+const MentionsInputComponent = ({ value, setValue, users: propsUsers, placeholder = "Type your reply here...", onEnterKeypress })=>{
+    const users = propsUsers.map((user)=>({
+            ...user,
+            display: user.display_name
+        }));
+    const onKeyDown = (e)=>{
+        e.stopPropagation();
+        if ("Enter" === e.key && !e.shiftKey) {
+            e.preventDefault();
+            onEnterKeypress?.();
+        }
+    };
+    const onAdd = (id, display)=>{
+        console.info("[MentionsInputComponent] on mention select", {
+            id,
+            display
+        });
+    };
+    const handleChange = (e)=>{
+        setValue(e.target.value);
+    };
+    return /*#__PURE__*/ jsx(MentionsInput, {
+        autoFocus: true,
+        value: value,
+        onChange: handleChange,
+        style: {
+            ...StyleMentionInput,
+            minHeight: "40px",
+            marginBottom: "10px"
+        },
+        placeholder: placeholder,
+        className: "mentions-input",
+        onKeyDown: onKeyDown,
+        children: /*#__PURE__*/ jsx(Mention, {
+            displayTransform: (_id, display)=>`@${display}`,
+            trigger: "@",
+            markup: "@[__id__](__display__)",
+            data: users,
+            appendSpaceOnAdd: true,
+            renderSuggestion: (highlightedDisplay, focused)=>/*#__PURE__*/ jsx("div", {
+                    className: `user ${focused ? "focused" : ""}`,
+                    children: highlightedDisplay.display
+                }),
+            onAdd: onAdd
+        })
+    });
+};
+const mentions_MentionsInput = MentionsInputComponent;
+const ConversationInputForm = ({ comment, setComment, loading, users, currentUser, placeholder, onEnterKeypress })=>/*#__PURE__*/ jsxs("div", {
+        className: styles_module.conversationInputForm,
+        children: [
+            currentUser ? /*#__PURE__*/ jsx(user_ProfileImageByUser, {
+                user: currentUser
+            }) : null,
+            /*#__PURE__*/ jsx(mentions_MentionsInput, {
+                value: comment,
+                setValue: setComment,
+                users: users,
+                placeholder: placeholder,
+                onEnterKeypress: onEnterKeypress
+            }),
+            /*#__PURE__*/ jsx(LoadingButton, {
+                loading: loading,
+                color: "primary",
+                children: /*#__PURE__*/ jsx(AskIcon, {})
+            })
+        ]
+    });
+const collaboration_ConversationInputForm = ConversationInputForm;
+const ConversationHighlightText = ({ meta: { highlight: text, filePath, field, column } })=>{
+    if (!text) return null;
+    const path = column ? `${filePath} (${column})` : filePath;
+    return /*#__PURE__*/ jsx("div", {
+        className: styles_module.highlightText,
+        children: /*#__PURE__*/ jsx(CodeBlock, {
+            code: text,
+            language: field ? "markdown" : "sql",
+            showLineNumbers: !field,
+            fileName: path,
+            theme: "light"
+        })
+    });
+};
+const conversations_ConversationHighlightText = ConversationHighlightText;
+const NewConversationForm = ()=>{
+    const usersList = useDbtDocsCollaborationSelector((state)=>state.users);
+    const newConversation = useDbtDocsCollaborationSelector((state)=>state.newConversation);
+    const currentUser = useDbtDocsCollaborationSelector((state)=>state.currentUserId ? state.users[state.currentUserId] : null);
+    const shareId = useDbtDocsCollaborationSelector((state)=>state.shareId);
+    const dispatch = useDbtDocsCollaborationDispatch();
+    const [loading, setLoading] = external_react_useState(false);
+    const [comment, setComment] = external_react_useState("");
+    const handleSubmit = async (e)=>{
+        e?.stopPropagation();
+        e?.preventDefault();
+        if (!newConversation || !shareId) return;
+        setLoading(true);
+        try {
+            console.log("saving conversation", newConversation, comment);
+            const createGroupResponse = await createNewConversationGroup(shareId, {
+                ...newConversation,
+                message: comment
+            }, "dbt-docs");
+            if (!createGroupResponse.conversation_group_id) return void console.error("Unable to create conversation group", createGroupResponse);
+            console.log("Successfully created conversation group", createGroupResponse);
+        } catch (err) {
+            console.error("error while saving conversation", newConversation, err);
+        }
+        dispatch(refetchConversations());
+        setLoading(false);
+        dispatch(updateRightPanelState(true));
+        dispatch(resetNewConversation());
+        setComment("");
+    };
+    return /*#__PURE__*/ jsx(Card, {
+        className: styles_module.newConversationForm,
+        children: /*#__PURE__*/ jsx(CardContent, {
+            className: "al-pt-4",
+            children: /*#__PURE__*/ jsxs("form", {
+                onSubmit: handleSubmit,
+                children: [
+                    /*#__PURE__*/ jsx("h4", {
+                        children: "Add comment"
+                    }),
+                    /*#__PURE__*/ jsx(conversations_ConversationHighlightText, {
+                        meta: newConversation?.meta || {}
+                    }),
+                    /*#__PURE__*/ jsx(collaboration_ConversationInputForm, {
+                        comment: comment,
+                        setComment: setComment,
+                        loading: loading,
+                        users: Object.values(usersList),
+                        currentUser: currentUser,
+                        placeholder: "Start a conversation or add others with @",
+                        onEnterKeypress: handleSubmit
+                    })
+                ]
+            })
+        })
+    });
+};
+const collaboration_NewConversationForm = NewConversationForm;
+const ResolveButton = ({ conversationGroupId, shareId })=>{
+    const { onResolve, source } = useConversationGroupContext();
+    const [loading, setLoading] = external_react_useState(false);
+    const handleClick = async ()=>{
+        if (!conversationGroupId) return;
+        setLoading(true);
+        await api_resolveConversationGroup(shareId, conversationGroupId, source);
+        onResolve();
+        setLoading(false);
+    };
+    if (!conversationGroupId) return null;
+    return /*#__PURE__*/ jsx(IconButton, {
+        disabled: loading,
+        className: styles_module.resolveButton,
+        title: "Resolve conversation",
+        onClick: handleClick,
+        children: /*#__PURE__*/ jsx(CheckNoOutlineIcon, {})
+    });
+};
+const conversations_ResolveButton = ResolveButton;
+const ConversationHeader = ({ user, timestamp, showResolveButton, conversationGroupId, shareId })=>/*#__PURE__*/ jsx(CardTitle, {
+        children: /*#__PURE__*/ jsxs(Stack, {
+            align: "center",
+            justify: "between",
+            className: "mb-0",
+            children: [
+                /*#__PURE__*/ jsxs(Stack, {
+                    align: "center",
+                    children: [
+                        /*#__PURE__*/ jsx(user_ProfileImageByUser, {
+                            user: user
+                        }),
+                        /*#__PURE__*/ jsxs("h4", {
+                            children: [
+                                user?.first_name,
+                                " ",
+                                user?.last_name
+                            ]
+                        }),
+                        /*#__PURE__*/ jsx("span", {
+                            children: dayjs(timestamp).format("HH:mm, DD MMM YY")
+                        })
+                    ]
+                }),
+                showResolveButton ? /*#__PURE__*/ jsx(conversations_ResolveButton, {
+                    conversationGroupId: conversationGroupId,
+                    shareId: shareId
+                }) : null
+            ]
+        })
+    });
+const conversations_ConversationHeader = ConversationHeader;
+const ConversationComponent = ({ conversation, shareId })=>{
+    const { users } = useConversationGroupContext();
+    const user = useMemo(()=>{
+        if (!conversation?.user_id) return;
+        return users[conversation.user_id];
+    }, [
+        conversation.user_id,
+        users
+    ]);
+    return /*#__PURE__*/ jsxs(Card, {
+        children: [
+            /*#__PURE__*/ jsx(conversations_ConversationHeader, {
+                user: user,
+                timestamp: conversation.timestamp,
+                shareId: shareId
+            }),
+            /*#__PURE__*/ jsx(CardContent, {
+                children: /*#__PURE__*/ jsx("p", {
+                    children: conversation.message.replace(/@\[(.*?)\]\((.*?)\)/g, "@$2")
+                })
+            })
+        ]
+    });
+};
+const Conversation = ConversationComponent;
+const ConversationReplyForm = ({ conversationGroupId, shareId })=>{
+    const { currentUser, users, onReplyAdd, source } = useConversationGroupContext();
+    const usersList = Object.values(users);
+    const [replyText, setReplyText] = external_react_useState("");
+    const [isLoading, setIsLoading] = external_react_useState(false);
+    const submitReply = async (e)=>{
+        e?.stopPropagation();
+        e?.preventDefault();
+        if (!shareId || !conversationGroupId) return;
+        setIsLoading(true);
+        console.log("saving reply", shareId, conversationGroupId, {
+            message: replyText
+        });
+        try {
+            await addConversationToGroup(shareId, conversationGroupId, {
+                message: replyText
+            }, source);
+            onReplyAdd();
+        } catch (err) {
+            console.error("error while saving reply", err);
+        }
+        setIsLoading(false);
+        setReplyText("");
+    };
+    return /*#__PURE__*/ jsx("div", {
+        className: styles_module.replyForm,
+        children: /*#__PURE__*/ jsx("form", {
+            onSubmit: submitReply,
+            className: "",
+            children: /*#__PURE__*/ jsx(collaboration_ConversationInputForm, {
+                comment: replyText,
+                setComment: setReplyText,
+                loading: isLoading,
+                users: Object.values(usersList),
+                currentUser: currentUser || null,
+                onEnterKeypress: submitReply
+            })
+        })
+    });
+};
+const conversations_ConversationReplyForm = ConversationReplyForm;
+const ConversationGroupComponent = ({ conversationGroup, shareId, onSelect })=>{
+    const { users } = useConversationGroupContext();
+    const user = useMemo(()=>{
+        if (!conversationGroup.owner) return;
+        return users[conversationGroup.owner];
+    }, [
+        conversationGroup.owner,
+        users
+    ]);
+    const { isSelected } = useConversationGroupContext();
+    const [showReplies, setShowReplies] = external_react_useState(false);
+    const onRender = external_react_useCallback((node)=>{
+        if (!isSelected || !node) return;
+        console.log("ConversationGroupComponent scrolling", conversationGroup.conversation_group_id);
+        setTimeout(()=>{
+            node.scrollIntoView({
+                behavior: "smooth",
+                block: "center"
+            });
+        }, 1000);
+    }, [
+        conversationGroup.conversation_group_id,
+        isSelected
+    ]);
+    if (!conversationGroup?.conversations?.length || conversationGroup?.status !== "Pending") return null;
+    const [first, ...rest] = conversationGroup.conversations;
+    const replyButtonText = rest.length ? rest.length > 1 ? `${rest.length} replies` : `${rest.length} reply` : "Reply";
+    return /*#__PURE__*/ jsx("div", {
+        ref: onRender,
+        className: styles_module.conversationGroup,
+        children: /*#__PURE__*/ jsxs(Card, {
+            className: `${isSelected ? "active" : ""}`,
+            onClick: onSelect,
+            children: [
+                /*#__PURE__*/ jsx(conversations_ConversationHeader, {
+                    user: user,
+                    timestamp: first.timestamp,
+                    showResolveButton: true,
+                    conversationGroupId: conversationGroup.conversation_group_id,
+                    shareId: shareId
+                }),
+                /*#__PURE__*/ jsxs(CardContent, {
+                    children: [
+                        /*#__PURE__*/ jsx(conversations_ConversationHighlightText, {
+                            meta: conversationGroup.meta
+                        }),
+                        /*#__PURE__*/ jsx("p", {
+                            children: first.message.replace(/@\[(.*?)\]\((.*?)\)/g, "@$2")
+                        }),
+                        /*#__PURE__*/ jsx(Button, {
+                            onClick: ()=>setShowReplies((prev)=>!prev),
+                            variant: "link",
+                            children: replyButtonText
+                        }),
+                        rest.length ? /*#__PURE__*/ jsx(Fragment, {
+                            children: showReplies ? /*#__PURE__*/ jsx(Fragment, {
+                                children: rest.map((c)=>/*#__PURE__*/ jsx(Conversation, {
+                                        conversation: c,
+                                        shareId: shareId
+                                    }, c.conversation_id))
+                            }) : null
+                        }) : null,
+                        showReplies ? /*#__PURE__*/ jsx(conversations_ConversationReplyForm, {
+                            conversationGroupId: conversationGroup.conversation_group_id,
+                            shareId: shareId
+                        }) : null
+                    ]
+                })
+            ]
+        })
+    });
+};
+const ConversationGroup = ConversationGroupComponent;
+const ConversationGroupContext = /*#__PURE__*/ createContext({
+    users: {},
+    conversationGroup: void 0,
+    currentUser: void 0,
+    isSelected: false,
+    shareId: void 0,
+    onSelect: ()=>null,
+    onResolve: ()=>null,
+    onReplyAdd: ()=>null,
+    source: types_ConversationSources.DBT_DOCS
+});
+const ConversationGroupProvider = ({ currentUser, conversationGroup, shareId, onSelect, isSelected, users, onResolve, onReplyAdd, source })=>{
+    const values = useMemo(()=>({
+            currentUser,
+            conversationGroup,
+            shareId,
+            onSelect,
+            isSelected,
+            users,
+            onResolve,
+            onReplyAdd,
+            source
+        }), [
+        currentUser,
+        conversationGroup,
+        shareId,
+        onSelect,
+        isSelected,
+        users,
+        onResolve,
+        onReplyAdd,
+        source
+    ]);
+    if (!conversationGroup || !shareId) return null;
+    return /*#__PURE__*/ jsx(ConversationGroupContext.Provider, {
+        value: values,
+        children: /*#__PURE__*/ jsx(ConversationGroup, {
+            conversationGroup: conversationGroup,
+            shareId: shareId,
+            onSelect: onSelect
+        })
+    });
+};
+const ConversationsProvider = ConversationGroupProvider;
+const useConversationGroupContext = ()=>useContext(ConversationGroupContext);
+const ConversationGroups = ()=>{
+    const source = useDbtDocsCollaborationSelector((state)=>state.source);
+    const conversationGroups = useDbtDocsCollaborationSelector((state)=>state.conversations);
+    const selectedConversationId = useDbtDocsCollaborationSelector((state)=>state.selectedConversationId);
+    const shareId = useDbtDocsCollaborationSelector((state)=>state.shareId);
+    const users = useDbtDocsCollaborationSelector((state)=>state.users);
+    const currentUserId = useDbtDocsCollaborationSelector((state)=>state.currentUserId);
+    const dispatch = useDbtDocsCollaborationDispatch();
+    if (!currentUserId || !shareId) return null;
+    const user = users[currentUserId];
+    const onResolve = (conversationGroupId)=>{
+        dispatch(resolveConversationGroup({
+            shareId,
+            conversationGroupId
+        }));
+    };
+    const onSelect = (conversationGroupId)=>{
+        dispatch(updateSelectedConversationId(conversationGroupId));
+    };
+    const onReplyAdd = (conversationGroupId)=>{
+        console.log("onReplyAdd", conversationGroupId);
+        dispatch(refetchConversations());
+    };
+    if (!conversationGroups || !Object.keys(conversationGroups).length) return /*#__PURE__*/ jsx("div", {
+        children: "No conversations yet!"
+    });
+    return /*#__PURE__*/ jsx("div", {
+        children: Object.values(conversationGroups).map((conversationGroup)=>/*#__PURE__*/ jsx(ConversationsProvider, {
+                conversationGroup: conversationGroup,
+                shareId: shareId,
+                isSelected: selectedConversationId === conversationGroup.conversation_group_id,
+                currentUser: user,
+                onResolve: ()=>onResolve(conversationGroup.conversation_group_id),
+                onSelect: ()=>onSelect(conversationGroup.conversation_group_id),
+                users: users,
+                onReplyAdd: ()=>onReplyAdd(conversationGroup.conversation_group_id),
+                source: source
+            }, conversationGroup.conversation_group_id))
+    });
+};
+const conversations_ConversationGroups = ConversationGroups;
+const DbtDocsConversationsRightPanel = ()=>{
+    const isRightPanelOpen = useDbtDocsCollaborationSelector((state)=>state.isRightPanelOpen);
+    const selectedConversationId = useDbtDocsCollaborationSelector((state)=>state.selectedConversationId);
+    const newConversation = useDbtDocsCollaborationSelector((state)=>state.newConversation);
+    const dispatch = useDbtDocsCollaborationDispatch();
+    const handleClose = ()=>{
+        dispatch(updateRightPanelState(false));
+        dispatch(updateSelectedConversationId(void 0));
+        dispatch(resetNewConversation());
+    };
+    const isOpen = !!newConversation || isRightPanelOpen || selectedConversationId;
+    if (!isOpen) return null;
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(Button, {
+                variant: "ghost",
+                onClick: handleClose,
+                className: styles_module.conversationRightPanelCloseButton,
+                children: /*#__PURE__*/ jsx(CloseIcon, {})
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: styles_module.conversationRightPanel,
+                children: [
+                    /*#__PURE__*/ jsx("h3", {
+                        children: "Comments"
+                    }),
+                    newConversation ? /*#__PURE__*/ jsx(collaboration_NewConversationForm, {}) : /*#__PURE__*/ jsx(conversations_ConversationGroups, {})
+                ]
+            })
+        ]
+    });
+};
+const collaboration_DbtDocsConversationsRightPanel = DbtDocsConversationsRightPanel;
+const PollingInterval = 10;
+const useConversations = ()=>{
+    const timer = useRef();
+    const shareId = useDbtDocsCollaborationSelector((state)=>state.shareId);
+    const loadingState = useDbtDocsCollaborationSelector((state)=>state.conversationsLoadingState);
+    const dispatch = useDbtDocsCollaborationDispatch();
+    const conversations = useDbtDocsCollaborationSelector((state)=>Object.keys(state.conversations || {}));
+    const fetchConversations = external_react_useCallback((shareId)=>{
+        clearTimeout(timer.current);
+        getConversationsByShareId(shareId).then((data)=>{
+            console.log("useConversations", data);
+            dispatch(setConversations(data?.dbt_docs_share_conversations));
+            timer.current = setTimeout(()=>{
+                fetchConversations(shareId);
+            }, 1000 * PollingInterval);
+        }).catch((err)=>console.error("error while fetching conversations list", err)).finally(()=>{
+            dispatch(setConversationsLoadingState(2));
+        });
+    }, [
+        dispatch
+    ]);
+    external_react_useEffect(()=>{
+        if (1 !== loadingState || !shareId) return;
+        dispatch(setConversationsLoadingState(0));
+        fetchConversations(shareId);
+    }, [
+        dispatch,
+        loadingState,
+        conversations,
+        shareId,
+        fetchConversations
+    ]);
+    return {
+        isLoading: 0 === loadingState
+    };
+};
+const conversations_useConversations = useConversations;
+const useConversationUsers = ()=>{
+    const dispatch = useDbtDocsCollaborationDispatch();
+    const users = useDbtDocsCollaborationSelector((state)=>Object.keys(state.users || {}));
+    const [loadingState, setLoadingState] = external_react_useState(1);
+    external_react_useEffect(()=>{
+        if (1 !== loadingState || Object.keys(users).length) return;
+        setLoadingState(0);
+        getUserList().then((data)=>{
+            console.log("useConversationUsers", data);
+            dispatch(setUsers(data));
+        }).catch((err)=>console.error("error while fetching users list", err)).finally(()=>{
+            setLoadingState(2);
+        });
+    }, [
+        dispatch,
+        loadingState,
+        users
+    ]);
+    return {
+        isLoading: 0 === loadingState
+    };
+};
+const collaboration_useConversationUsers = useConversationUsers;
+const DbtDocsCollaborationComponents = ()=>{
+    collaboration_useConversationUsers();
+    conversations_useConversations();
+    return /*#__PURE__*/ jsxs("div", {
+        children: [
+            /*#__PURE__*/ jsx(collaboration_DbtDocsConversationsRightPanel, {}),
+            /*#__PURE__*/ jsx(collaboration_ConversationsHighlighter, {})
+        ]
+    });
+};
+const collaboration_DbtDocsCollaborationComponents = DbtDocsCollaborationComponents;
+const HotspotButton = ({ target, ...rest })=>/*#__PURE__*/ createPortal(/*#__PURE__*/ jsx(IconButton, {
+        className: styles_module.hotspotButton,
+        title: "Click to start conversation",
+        ...rest,
+        children: /*#__PURE__*/ jsx(AddIcon, {})
+    }), target);
+const collaboration_HotspotButton = HotspotButton;
+const AddCommentOnCodeButton = ()=>{
+    const dispatch = useDbtDocsCollaborationDispatch();
+    const codeBlockUpdated = useDbtDocsCollaborationSelector((state)=>state.codeblockLoaded);
+    const manifest = useDbtDocsCollaborationSelector((state)=>state.manifest);
+    const [lineNumber, setLineNumber] = external_react_useState(0);
+    const codeElement = getCodeBlockElementInPage()?.parentElement;
+    const handleClick = ()=>{
+        if (!codeElement || !manifest.nodes) return;
+        const modelParts = getModelPartsFromLocationHash();
+        if (!modelParts || modelParts.length < 3) return void console.error("Unable to find model parts", modelParts);
+        const code = manifest.nodes[modelParts[2]]?.raw_code;
+        const data = {
+            highlight: code.split("\n")[lineNumber],
+            range: {
+                end: {
+                    line: lineNumber,
+                    character: 0
+                },
+                start: {
+                    line: lineNumber,
+                    character: 0
+                }
+            }
+        };
+        dispatch(updateNewConversation({
+            meta: data
+        }));
+    };
+    const onMouseMove = external_react_useCallback((e)=>{
+        if (!codeElement) return;
+        const endY = e.y;
+        const lineNumbers = codeElement.querySelectorAll(".line-numbers-rows > span");
+        const end = Array.from(lineNumbers).findIndex((node)=>{
+            const { height, y } = node.getBoundingClientRect();
+            return endY >= y && endY <= y + height;
+        });
+        setLineNumber(end);
+    }, [
+        codeElement
+    ]);
+    external_react_useEffect(()=>{
+        if (!codeBlockUpdated || !codeElement) return;
+        codeElement.addEventListener("mousemove", onMouseMove);
+        return ()=>{
+            codeElement.removeEventListener("mousemove", onMouseMove);
+        };
+    }, [
+        codeBlockUpdated,
+        codeElement,
+        onMouseMove
+    ]);
+    if (!codeBlockUpdated || !codeElement) return null;
+    return /*#__PURE__*/ jsx(collaboration_HotspotButton, {
+        target: codeElement,
+        onClick: handleClick,
+        style: {
+            top: 21.2 * lineNumber
+        }
+    });
+};
+const details_AddCommentOnCodeButton = AddCommentOnCodeButton;
+const AddCommentOnModelDescriptionButton = ()=>{
+    const dispatch = useDbtDocsCollaborationDispatch();
+    const codeBlockUpdated = useDbtDocsCollaborationSelector((state)=>state.codeblockLoaded);
+    const descriptionElement = getModelDescriptionElement();
+    const handleClick = ()=>{
+        const data = {
+            field: "description",
+            highlight: descriptionElement?.innerText
+        };
+        dispatch(updateNewConversation({
+            meta: data
+        }));
+    };
+    if (!codeBlockUpdated || !descriptionElement) return null;
+    return /*#__PURE__*/ jsx(collaboration_HotspotButton, {
+        target: descriptionElement,
+        onClick: handleClick
+    });
+};
+const details_AddCommentOnModelDescriptionButton = AddCommentOnModelDescriptionButton;
+const AddCommentButton = ()=>/*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(details_AddCommentOnModelDescriptionButton, {}),
+            /*#__PURE__*/ jsx(details_AddCommentOnCodeButton, {})
+        ]
+    });
+const details_AddCommentButton = AddCommentButton;
+const DbtDocsRenderer = /*#__PURE__*/ lazy(()=>import("./3~315.js").then((mod)=>({
+            default: mod.details_DbtDocsRenderer
+        })));
+const DbtDocsDetails = ()=>{
+    const { loading, shareDetails } = collaboration_useDbtDocsCollaboration();
+    const dispatch = useDbtDocsCollaborationDispatch();
+    const { getHighlightedSelectionData, pos, onSelectionEnd } = collaboration_useHighlight();
+    const onAddComment = (e)=>{
+        e.stopPropagation();
+        const data = getHighlightedSelectionData();
+        if (data) dispatch(updateNewConversation(data));
+    };
+    if (loading) return /*#__PURE__*/ jsx("div", {
+        children: "Loading..."
+    });
+    if (!shareDetails?.catalog_presigned_url || !shareDetails?.manifest_presigned_url) return /*#__PURE__*/ jsx("div", {
+        children: "Unable to load required artifacts. Please try again."
+    });
+    return /*#__PURE__*/ jsxs("div", {
+        children: [
+            /*#__PURE__*/ jsxs(Stack, {
+                direction: "row",
+                justify: "end",
+                className: "mb-2",
+                children: [
+                    /*#__PURE__*/ jsx(details_AddCommentButton, {}),
+                    /*#__PURE__*/ jsx(collaboration_ShowConversationsButton, {})
+                ]
+            }),
+            /*#__PURE__*/ jsx(collaboration_DbtDocsCollaborationComponents, {}),
+            /*#__PURE__*/ jsx(DbtDocsRenderer, {
+                shareDetails: shareDetails,
+                onSelectionEnd: onSelectionEnd
+            }),
+            pos ? /*#__PURE__*/ jsx(collaboration_HighlightAnchor, {
+                pos: pos,
+                onAddComment: onAddComment
+            }) : null
+        ]
+    });
+};
+const details_DbtDocsDetails = DbtDocsDetails;
+const DbtDocs = ({ shareId, userId, conversationGroupId, source })=>/*#__PURE__*/ jsx("div", {
+        className: "altimate-component",
+        children: /*#__PURE__*/ jsx(collaboration_DbtDocsCollaborationProvider, {
+            shareId: shareId,
+            userId: userId,
+            conversationGroupId: conversationGroupId,
+            source: source,
+            children: /*#__PURE__*/ jsx(details_DbtDocsDetails, {})
+        })
+    });
+const details_DbtDocs = DbtDocs;
+export { ApiHelper, ConversationsProvider as ConversationGroupProvider, Fragment, collaboration_ConversationInputForm as ConversationInputForm, details_DbtDocs as DbtDocs, external_react_useCallback, external_react_useEffect, getCodeBlockElementInPage, getResourceTypeAndPageFromUrlHash, getSelectionAllowedElements, jsx, jsxs, setDocsAppRendered, styles_module, types_ConversationSources as ConversationSources, updateCodeblockLoaded, updateCurrentPage, useDbtDocsCollaborationDispatch, useDbtDocsCollaborationSelector, useRef };
+
+//# sourceMappingURL=582.js.map