import { css, cx } from '@emotion/css';
import { ReactEditor } from '@src/components/slate-packages/slate-react';
import { Editor, Node } from '@src/components/slate-packages/slate';
import React, { useCallback, useEffect, useRef, useState } from 'react';
import { ELTYPE, HEADING_TYPES, LIST_TYPES } from '../config';
import { OlList, UlList } from '../OLULList/OlList';
import { getEditorEventEmitter } from '../table/selection';
import $ from 'jquery';
import { getCache } from '@src/utils/cacheUtils';
import _ from 'lodash';
import { Popover, Radio, Tooltip } from 'antd';
import { f } from '@src/resource/string';
import { ArrowRightOutlined, CaretDownOutlined, SettingOutlined } from '@ant-design/icons';
import { IconBtn } from '../Components';
import scrollIntoView from 'scroll-into-view-if-needed';
import './index.less';
import sessStorage from '@src/utils/sessStorage';
import { TODOList } from '../TodoList/todoList';
type DocTocTitleProps = {
showCollapseBtn: boolean;
isAnchorCollapsed: boolean;
handleDeepestHeading: (e) => void;
deepestDisplayAnchor: 3 | 4 | 5 | 6;
setIsAnchorCollapsed: Function;
tocPlacement: 'left' | 'right';
};
const DocTocTitle = (props: DocTocTitleProps) => {
const { showCollapseBtn, isAnchorCollapsed, handleDeepestHeading, deepestDisplayAnchor, setIsAnchorCollapsed, tocPlacement } = props;
return (
<>
{showCollapseBtn && (
{
e.preventDefault();
setIsAnchorCollapsed(true);
}}
/>
)}
{`${f('documentOutline')}`}
{`${f('deepestAnchorLevel')}`}
{`${f('heading')}`}
3
4
5
6
}
>
{}
>
);
};
const OutlineAnchor = (props: any) => {
const { editor, docId, scrollRef, deepestDisplayAnchor, isLarge, isMobile, isShowAnchor, maxWidth } = props;
const [focusedAnchorItemIndex, setFocusedAnchorItemIndex] = useState(-1);
const [headingTagList, setHeadingTagList] = useState([]);
const [unseenArr, setUnseenArr] = useState([]);
const [descendantMap, setDescendantMap] = useState({});
useEffect(() => {
const focusedAnchorItem = $(`#editorContainer-${docId} .anchor-container .anchor-item-group .focused-anchor-item`)[0];
if (focusedAnchorItem) {
scrollIntoView(focusedAnchorItem, {
block: 'nearest',
scrollMode: 'if-needed',
inline: 'center',
});
}
}, [focusedAnchorItemIndex]);
const listener = useCallback(
deepest => () => {
let hTagList = [];
const editor = window.tripdocs.editorsMap[docId].editor;
if (typeof window !== 'undefined' && window.document.getElementById(`editorContainer-${docId}`) && editor) {
const childrenArr = editor.children.slice();
childrenArr.shift();
hTagList = childrenArr.filter(
(element, index) =>
getText(element) !== '' &&
((HEADING_TYPES.includes(element.type) && HEADING_TYPES.indexOf(element.type) < deepest) ||
(HEADING_TYPES.includes(element.oldType) && LIST_TYPES.includes(element.type) && HEADING_TYPES.indexOf(element.oldType) < deepest))
);
}
let descendantUnseenArr = [];
let map = _.cloneDeep(descendantMap);
hTagList.forEach((item, index, arr) => {
const headTabLevel = getHeadTablevel(item.type, item.oldType);
if (descendantMap[index]) {
descendantUnseenArr = descendantMap[index];
} else {
for (let i = index + 1; i < arr.length; i++) {
const cur = arr[i];
if (getHeadTablevel(cur.type, cur.oldType) > headTabLevel) {
descendantUnseenArr.push(i);
} else {
break;
}
}
}
map[index] = descendantUnseenArr;
descendantUnseenArr = [];
});
console.log('ROA - hTagList: ', map);
getEditorEventEmitter(docId).emit('outline/updateIsExpanded', docId, JSON.stringify([]), true);
setUnseenArr([]);
setDescendantMap(map);
setHeadingTagList(hTagList);
},
[editor, docId]
);
useEffect(() => {
if (editor && docId) {
getEditorEventEmitter(docId).on('updateOutlineAnchor', listener(deepestDisplayAnchor), docId);
}
return () => {
getEditorEventEmitter(docId).off('updateOutlineAnchor', listener(deepestDisplayAnchor), docId);
};
}, [editor && editor.docId, deepestDisplayAnchor]);
const callback = useCallback(
_.throttle(() => {
const editorContent = document.getElementById(`editor-content-wrap-${docId}`);
if (headingTagList.length > 0 && editorContent) {
const headingDoms = headingTagList.map(heading => Node.isNode(heading) && ReactEditor.toDOMNode(editor, heading));
const editorContainerScrollTop = editorContent.scrollTop;
const editorContainerScrollBottom = editorContainerScrollTop + editorContent.clientHeight / 2;
let firstHead = headingDoms[0];
let firstHeadingIndex = 0;
for (let i = 0; i < headingDoms.length; i++) {
const headingDom = headingDoms[i];
const headingDomHeight = headingDom?.getBoundingClientRect?.()?.height || 32;
if (getText(headingTagList[i]).length > 0) {
const scrollTop = headingDom?.offsetTop + Math.floor(headingDomHeight / 2);
if (scrollTop > editorContainerScrollTop) {
firstHead = headingDom;
firstHeadingIndex = i;
break;
}
}
}
const headingDom = headingDoms[firstHeadingIndex];
const headingDomHeight = headingDom?.getBoundingClientRect?.()?.height || 32;
const scrollBottom = headingDom?.offsetTop - Math.floor(headingDomHeight / 2);
if (scrollBottom >= editorContainerScrollBottom && firstHeadingIndex > 0) {
firstHeadingIndex = firstHeadingIndex - 1;
}
const endHeadingDom = headingDoms[headingDoms.length - 1];
const endHeadingDomHeight = endHeadingDom?.getBoundingClientRect?.()?.height || 32;
if (endHeadingDom && endHeadingDom.offsetTop - Math.floor(endHeadingDomHeight) < editorContainerScrollTop) {
firstHeadingIndex = headingDoms.length - 1;
}
const anchorItemIndex = firstHeadingIndex;
if (anchorItemIndex !== -1) {
setFocusedAnchorItemIndex(anchorItemIndex);
}
}
}, 100),
[headingTagList]
);
useEffect(() => {
const root = document.querySelector(`#editor-content-wrap-${docId}`);
if (!root) return;
root.addEventListener('scroll', callback);
if (focusedAnchorItemIndex == -1) {
callback();
}
return () => {
root.removeEventListener('scroll', callback);
};
}, [headingTagList]);
const getHeadTablevel = useCallback((type, oldType) => {
let ret = {};
ret[ELTYPE.HEADING_ONE] = 1;
ret[ELTYPE.HEADING_TWO] = 2;
ret[ELTYPE.HEADING_THREE] = 3;
ret[ELTYPE.HEADING_FOUR] = 4;
ret[ELTYPE.HEADING_FIVE] = 5;
ret[ELTYPE.HEADING_SIX] = 6;
return (typeof ret[type] === 'number' && ret[type]) || (typeof ret[oldType] === 'number' && ret[oldType]) || 1;
}, []);
const getText = useCallback(el => {
if (el && el.text) return el.text;
if (el && el.children) return getText(el.children);
if (el && Array.isArray(el)) return el.reduce((prev: any, item: any) => '' + prev + getText(item), '');
return '';
}, []);
const wrapTextWithStyle = useCallback((item, txt: string) => {
const text = txt.replace(/^\s*/, '');
if (!item?.type) return text;
const { type } = item;
let styled = text;
switch (type) {
case 'bulleted-list':
if (isMobile) {
styled = {text};
} else {
styled = (
{text}
);
}
break;
case 'numbered-list':
if (isMobile) {
styled = {item.num + '. ' + text};
} else {
styled = (
{text}
);
}
break;
case 'todo-list':
styled = (
{text}
);
break;
}
return styled;
}, []);
const isAnchorDrawer = !isLarge && isShowAnchor;
const editorContainer = document.getElementById(`editorContainer-${docId}`);
const editorContainerWidth = editorContainer?.getBoundingClientRect().width;
const anchorItemWidth = isAnchorDrawer ? `250px` : maxWidth;
return (
<>
{headingTagList.length === 0 ? (
{f('emptyAnchorPlaceholder1')}
{f('emptyAnchorPlaceholder2')}
) : (
headingTagList.map((item, index, arr) => {
const anchorItemText = item?.children && item?.children.map(leaf => getText(leaf)).join('');
const headTabLevel = getHeadTablevel(item.type, item.oldType);
return (
{
setFocusedAnchorItemIndex(index);
ReactEditor.deselect(editor);
const originItem = headingTagList[index];
const anchorItemEl = ReactEditor.toDOMNode(editor, originItem);
console.log('[outlineAnchor] scrollIntoView anchorItemEl', anchorItemEl);
scrollRef.current.scrollTo({ top: anchorItemEl.offsetTop - 20 });
$(anchorItemEl).on('webkitAnimationEnd animationEnd', function () {
$(this).removeClass('anchor-target');
});
$(anchorItemEl).addClass('anchor-target');
}}
>
{wrapTextWithStyle(item, anchorItemText)}
);
})
)}
>
);
};
function CollapseBtn(props) {
const { docId, headTabLevel, index, arr, getHeadTablevel, unseenArr, setUnseenArr, descendantMap } = props;
const [isExpanded, setIsExpanded] = useState(unseenArr.includes(index) || true);
const isMounted = useRef(false);
useEffect(() => {
isMounted.current = true;
const handleUpdateIsExpanded = (unseenArrStr: string, refreshAll?: boolean) => {
const arr = JSON.parse(unseenArrStr);
if (arr.includes(index) || refreshAll) {
setIsExpanded(true);
}
};
getEditorEventEmitter(docId).on('outline/updateIsExpanded', handleUpdateIsExpanded, docId);
return () => {
getEditorEventEmitter(docId).off('outline/updateIsExpanded', handleUpdateIsExpanded, docId);
};
}, []);
useEffect(() => {
const descendants = descendantMap[index];
if (!descendants || isMounted.current) return;
const newUnseenArr = unseenArr.filter(item => !descendants.includes(item));
console.log('ROA - newUnseenArr init', newUnseenArr);
descendants && descendants.length && setUnseenArr(newUnseenArr);
}, [descendantMap]);
const _onMouseDown = e => {
e.preventDefault();
e.stopPropagation();
const descendants = descendantMap[index];
console.log('ROA - descendants', descendantMap, index, descendants, unseenArr);
if (!descendants || !descendants.length) {
return;
}
if (isExpanded) {
const newUnseenArr = _.uniqWith([...unseenArr, ...descendants], _.isEqual);
console.log('ROA - newUnseenArr0', newUnseenArr);
setUnseenArr(newUnseenArr);
setIsExpanded(false);
} else {
const newUnseenArr = unseenArr.filter(item => !descendants.includes(item));
getEditorEventEmitter(docId).emit('outline/updateIsExpanded', docId, JSON.stringify(unseenArr.filter(item => descendants.includes(item))));
console.log('ROA - newUnseenArr1', newUnseenArr);
setUnseenArr(newUnseenArr);
setIsExpanded(true);
}
console.log('ROA - res', isExpanded, unseenArr, index);
};
return (
0 ? 'flex' : 'none',
transform: isExpanded ? null : 'rotate(-90deg)',
}}
onMouseDown={_onMouseDown}
>
{}
);
}
export { OutlineAnchor, DocTocTitle };