23ae19c0-0cd4-4c43-a253-faadd5039d91

Committed 04 Dec 2023 03:35AM UTC coverage: 48.224% (-0.02%) from 48.243%

Build # 23ae19c0-0cd4-4c43-a253-faadd5039d91

Build Type

push

circleci

Committed by

pubuzhixing8

Commit Message

feat(core): remove path from SlateElementContext

Run Details

377 of 962 branches covered (0.0%)

Branch coverage included in aggregate %.

8 of 9 new or added lines in 3 files covered. (88.89%)

1 existing line in 1 file now uncovered.

940 of 1769 relevant lines covered (53.14%)

41.18 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.4

/packages/src/view/render/list-render.ts

import { Ancestor, Descendant, Range, Editor, Element, Path } from 'slate';
import { ComponentRef, EmbeddedViewRef, IterableDiffer, IterableDiffers, ViewContainerRef } from '@angular/core';
import { ViewType } from '../../types/view';
import { SlateChildrenContext, SlateElementContext, SlateTextContext, SlateViewContext } from '../context';
import { AngularEditor } from '../../plugins/angular-editor';
import { SlateErrorCode } from '../../types/error';
import { NODE_TO_INDEX, NODE_TO_PARENT } from '../../utils/weak-maps';
import { isDecoratorRangeListEqual } from '../../utils/range-list';
import { SlateBlockCard } from '../../components/block-card/block-card.component';
import { createEmbeddedViewOrComponent, getRootNodes, mount, mountOnItemChange, renderView, updateContext } from './utils';

export class ListRender {
    private children: Descendant[];
    private views: (EmbeddedViewRef<any> | ComponentRef<any>)[] = [];
    private blockCards: (ComponentRef<SlateBlockCard> | null)[] = [];
    private contexts: (SlateTextContext | SlateElementContext)[] = [];
    private viewTypes: ViewType[] = [];
    private differ: IterableDiffer<any>;
    public initialized = false;

    constructor(
        private viewContext: SlateViewContext,
        private viewContainerRef: ViewContainerRef,
        private getOutletElement: () => HTMLElement
    ) {}

    public initialize(children: Descendant[], parent: Ancestor, childrenContext: SlateChildrenContext) {
        this.initialized = true;
        this.children = children;
        const parentPath = AngularEditor.findPath(this.viewContext.editor, parent);
        children.forEach((descendant, index) => {
            NODE_TO_INDEX.set(descendant, index);
            NODE_TO_PARENT.set(descendant, parent);
            const context = getContext(index, descendant, parentPath, childrenContext, this.viewContext);
            const viewType = getViewType(descendant, parent, this.viewContext);
            const view = createEmbeddedViewOrComponent(viewType, context, this.viewContext, this.viewContainerRef);
            const blockCard = createBlockCard(descendant, view, this.viewContainerRef, this.viewContext);
            this.views.push(view);
            this.contexts.push(context);
            this.viewTypes.push(viewType);
            this.blockCards.push(blockCard);
        });
        mount(this.views, this.blockCards, this.getOutletElement());
        const newDiffers = this.viewContainerRef.injector.get(IterableDiffers);
        this.differ = newDiffers.find(children).create(trackBy(this.viewContext));
        this.differ.diff(children);
    }

    public update(children: Descendant[], parent: Ancestor, childrenContext: SlateChildrenContext) {
        if (!this.initialized) {
            this.initialize(children, parent, childrenContext);
            return;
        }
        const outletElement = this.getOutletElement();
        const diffResult = this.differ.diff(children);
        const parentPath = AngularEditor.findPath(this.viewContext.editor, parent);
        if (diffResult) {
            const newContexts = [];
            const newViewTypes = [];
            const newViews = [];
            const newBlockCards: (ComponentRef<SlateBlockCard> | null)[] = [];
            diffResult.forEachItem(record => {
                NODE_TO_INDEX.set(record.item, record.currentIndex);
                NODE_TO_PARENT.set(record.item, parent);
                let context = getContext(record.currentIndex, record.item, parentPath, childrenContext, this.viewContext);
                const viewType = getViewType(record.item, parent, this.viewContext);
                newViewTypes.push(viewType);
                let view: EmbeddedViewRef<any> | ComponentRef<any>;
                let blockCard: ComponentRef<SlateBlockCard> | null;
                if (record.previousIndex === null) {
                    view = createEmbeddedViewOrComponent(viewType, context, this.viewContext, this.viewContainerRef);
                    blockCard = createBlockCard(record.item, view, this.viewContainerRef, this.viewContext);
                    newContexts.push(context);
                    newViews.push(view);
                    newBlockCards.push(blockCard);
                    mountOnItemChange(record.currentIndex, record.item, newViews, newBlockCards, outletElement, this.viewContext);
                } else {
                    const previousView = this.views[record.previousIndex];
                    const previousViewType = this.viewTypes[record.previousIndex];
                    const previousContext = this.contexts[record.previousIndex];
                    const previousBlockCard = this.blockCards[record.previousIndex];
                    if (previousViewType !== viewType) {
                        view = createEmbeddedViewOrComponent(viewType, context, this.viewContext, this.viewContainerRef);
                        blockCard = createBlockCard(record.item, view, this.viewContainerRef, this.viewContext);
                        const firstRootNode = getRootNodes(previousView, previousBlockCard)[0];
                        const newRootNodes = getRootNodes(view, blockCard);
                        firstRootNode.replaceWith(...newRootNodes);
                        previousView.destroy();
                        previousBlockCard?.destroy();
                    } else {
                        view = previousView;
                        blockCard = previousBlockCard;
                        if (memoizedContext(this.viewContext, record.item, previousContext as any, context as any)) {
                            context = previousContext;
                        } else {
                            updateContext(previousView, context, this.viewContext);
                        }
                    }
                    newContexts.push(context);
                    newViews.push(view);
                    newBlockCards.push(blockCard);
                }
            });
            diffResult.forEachOperation((record) => {
                // removed
                if (record.currentIndex === null) {
                    const view = this.views[record.previousIndex];
                    const blockCard = this.blockCards[record.previousIndex];
                    view.destroy();
                    blockCard?.destroy();
                }
                // moved
                if (record.previousIndex !== null && record.currentIndex !== null) {
                    mountOnItemChange(record.currentIndex, record.item, newViews, newBlockCards, outletElement, this.viewContext);
                    // Solve the block-card DOMElement loss when moving nodes
                    newBlockCards[record.currentIndex]?.instance.append();
                }
            });
            this.viewTypes = newViewTypes;
            this.views = newViews;
            this.contexts = newContexts;
            this.children = children;
            this.blockCards = newBlockCards;
        } else {
            const newContexts = [];
            this.children.forEach((child, index) => {
                let context = getContext(index, child, parentPath, childrenContext, this.viewContext);
                const previousContext = this.contexts[index];
                if (memoizedContext(this.viewContext, child, previousContext as any, context as any)) {
                    context = previousContext;
                } else {
                    updateContext(this.views[index], context, this.viewContext);
                }
                newContexts.push(context);
            });
            this.contexts = newContexts;
        }
    }
}

export function getContext(
    index: number,
    item: Descendant,
    parentPath: Path,
    childrenContext: SlateChildrenContext,
    viewContext: SlateViewContext
): SlateElementContext | SlateTextContext {
    if (Element.isElement(item)) {
        const computedContext = getCommonContext(index, item, parentPath, viewContext, childrenContext);
        const key = AngularEditor.findKey(viewContext.editor, item);
        const isInline = viewContext.editor.isInline(item);
        const isVoid = viewContext.editor.isVoid(item);
        const elementContext: SlateElementContext = {
            element: item,
            ...computedContext,
            attributes: {
                'data-slate-node': 'element',
                'data-slate-key': key.id
            },
            decorate: childrenContext.decorate,
            readonly: childrenContext.readonly
        };
        if (isInline) {
            elementContext.attributes['data-slate-inline'] = true;
        }
        if (isVoid) {
            elementContext.attributes['data-slate-void'] = true;
            elementContext.attributes.contenteditable = false;
        }
        return elementContext;
    } else {
        const computedContext = getCommonContext(index, item, parentPath, viewContext, childrenContext);
        const isLeafBlock = AngularEditor.isLeafBlock(viewContext.editor, childrenContext.parent);
        const textContext: SlateTextContext = {
            decorations: computedContext.decorations,
            isLast: isLeafBlock && index === childrenContext.parent.children.length - 1,
            parent: childrenContext.parent as Element,
            text: item
        };
        return textContext;
    }
}

export function getCommonContext(
    index: number,
    item: Descendant,
    parentPath: Path,
    viewContext: SlateViewContext,
    childrenContext: SlateChildrenContext
): { selection: Range; decorations: Range[] } {
    const p = parentPath.concat(index);
    try {
        const ds = childrenContext.decorate([item, p]);
        // [list-render] performance optimization: reduce the number of calls to the `Editor.range(viewContext.editor, p)` method
        if (childrenContext.selection || childrenContext.decorations.length > 0) {
            const range = Editor.range(viewContext.editor, p);
            const sel = childrenContext.selection && Range.intersection(range, childrenContext.selection);
            for (const dec of childrenContext.decorations) {
                const d = Range.intersection(dec, range);
                if (d) {
                    ds.push(d);
                }
            }
            return { selection: sel, decorations: ds };
        } else {
            return { selection: null, decorations: ds };
        }
    } catch (error) {
        this.options.viewContext.editor.onError({
            code: SlateErrorCode.GetStartPointError,
            nativeError: error
        });
        return { selection: null, decorations: [] };
    }
}

export function getViewType(item: Descendant, parent: Ancestor, viewContext: SlateViewContext) {
    if (Element.isElement(item)) {
        return (viewContext.renderElement && viewContext.renderElement(item)) || viewContext.defaultElement;
    } else {
        const isVoid = viewContext.editor.isVoid(parent as Element);
        return isVoid ? viewContext.defaultVoidText : (viewContext.renderText && viewContext.renderText(item)) || viewContext.defaultText;
    }
}

export function createBlockCard(item: Descendant, view: EmbeddedViewRef<any> | ComponentRef<any>, viewContainerRef: ViewContainerRef, viewContext: SlateViewContext) {
    const isBlockCard = viewContext.editor.isBlockCard(item);
    if (isBlockCard) {
        const rootNodes = getRootNodes(view);
        const blockCardComponentRef = viewContainerRef.createComponent<SlateBlockCard>(SlateBlockCard, {
            injector: viewContainerRef.injector
        });
        blockCardComponentRef.instance.initializeCenter(rootNodes);
        return blockCardComponentRef;
    } else {
        return null;
    }
}

export function trackBy(viewContext: SlateViewContext) {
    return (index, node) => {
        return viewContext.trackBy(node) || AngularEditor.findKey(viewContext.editor, node);
    };
}

export function memoizedContext(
    viewContext: SlateViewContext,
    descendant: Descendant,
    prev: SlateElementContext | SlateTextContext,
    next: SlateElementContext | SlateTextContext
): boolean {
    if (Element.isElement(descendant)) {
        return memoizedElementContext(viewContext, prev as SlateElementContext, next as SlateElementContext);
    } else {
        return memoizedTextContext(prev as SlateTextContext, next as SlateTextContext);
    }
}

export function memoizedElementContext(viewContext: SlateViewContext, prev: SlateElementContext, next: SlateElementContext) {
    return (
        prev.element === next.element &&
        (!viewContext.isStrictDecorate || prev.decorate === next.decorate) &&
        prev.readonly === next.readonly &&
        isDecoratorRangeListEqual(prev.decorations, next.decorations) &&
        (prev.selection === next.selection || (!!prev.selection && !!next.selection && Range.equals(prev.selection, next.selection)))
    );
}

export function memoizedTextContext(prev: SlateTextContext, next: SlateTextContext) {
    return (
        next.parent === prev.parent &&
        next.isLast === prev.isLast &&
        next.text === prev.text &&
        isDecoratorRangeListEqual(next.decorations, prev.decorations)
    );
}

1	import { Ancestor, Descendant, Range, Editor, Element, Path } from 'slate';
2	import { ComponentRef, EmbeddedViewRef, IterableDiffer, IterableDiffers, ViewContainerRef } from '@angular/core';
3	import { ViewType } from '../../types/view';
4	import { SlateChildrenContext, SlateElementContext, SlateTextContext, SlateViewContext } from '../context';
5	import { AngularEditor } from '../../plugins/angular-editor';
6	import { SlateErrorCode } from '../../types/error';
7	import { NODE_TO_INDEX, NODE_TO_PARENT } from '../../utils/weak-maps';
8	import { isDecoratorRangeListEqual } from '../../utils/range-list';
9	import { SlateBlockCard } from '../../components/block-card/block-card.component';
10	import { createEmbeddedViewOrComponent, getRootNodes, mount, mountOnItemChange, renderView, updateContext } from './utils';
11
12	export class ListRender {
13	private children: Descendant[];
14	private views: (EmbeddedViewRef<any> \| ComponentRef<any>)[] = [];	204✔
15	private blockCards: (ComponentRef<SlateBlockCard> \| null)[] = [];	204✔
16	private contexts: (SlateTextContext \| SlateElementContext)[] = [];	204✔
17	private viewTypes: ViewType[] = [];	204✔
18	private differ: IterableDiffer<any>;
19	public initialized = false;	204✔
20
21	constructor(
22	private viewContext: SlateViewContext,	204✔
23	private viewContainerRef: ViewContainerRef,	204✔
24	private getOutletElement: () => HTMLElement	204✔
25	) {}
26
27	public initialize(children: Descendant[], parent: Ancestor, childrenContext: SlateChildrenContext) {
28	this.initialized = true;	204✔
29	this.children = children;	204✔
30	const parentPath = AngularEditor.findPath(this.viewContext.editor, parent);	204✔
31	children.forEach((descendant, index) => {	204✔
32	NODE_TO_INDEX.set(descendant, index);	319✔
33	NODE_TO_PARENT.set(descendant, parent);	319✔
34	const context = getContext(index, descendant, parentPath, childrenContext, this.viewContext);	319✔
35	const viewType = getViewType(descendant, parent, this.viewContext);	319✔
36	const view = createEmbeddedViewOrComponent(viewType, context, this.viewContext, this.viewContainerRef);	319✔
37	const blockCard = createBlockCard(descendant, view, this.viewContainerRef, this.viewContext);	319✔
38	this.views.push(view);	319✔
39	this.contexts.push(context);	319✔
40	this.viewTypes.push(viewType);	319✔
41	this.blockCards.push(blockCard);	319✔
42	});
43	mount(this.views, this.blockCards, this.getOutletElement());	204✔
44	const newDiffers = this.viewContainerRef.injector.get(IterableDiffers);	204✔
45	this.differ = newDiffers.find(children).create(trackBy(this.viewContext));	204✔
46	this.differ.diff(children);	204✔
47	}
48
49	public update(children: Descendant[], parent: Ancestor, childrenContext: SlateChildrenContext) {
50	if (!this.initialized) {	37!
NEW 51	this.initialize(children, parent, childrenContext);	×
52	return;	×
53	}
54	const outletElement = this.getOutletElement();	37✔
55	const diffResult = this.differ.diff(children);	37✔
56	const parentPath = AngularEditor.findPath(this.viewContext.editor, parent);	37✔
57	if (diffResult) {	37✔
58	const newContexts = [];	25✔
59	const newViewTypes = [];	25✔
60	const newViews = [];	25✔
61	const newBlockCards: (ComponentRef<SlateBlockCard> \| null)[] = [];	25✔
62	diffResult.forEachItem(record => {	25✔
63	NODE_TO_INDEX.set(record.item, record.currentIndex);	59✔
64	NODE_TO_PARENT.set(record.item, parent);	59✔
65	let context = getContext(record.currentIndex, record.item, parentPath, childrenContext, this.viewContext);	59✔
66	const viewType = getViewType(record.item, parent, this.viewContext);	59✔
67	newViewTypes.push(viewType);	59✔
68	let view: EmbeddedViewRef<any> \| ComponentRef<any>;
69	let blockCard: ComponentRef<SlateBlockCard> \| null;
70	if (record.previousIndex === null) {	59✔
71	view = createEmbeddedViewOrComponent(viewType, context, this.viewContext, this.viewContainerRef);	6✔
72	blockCard = createBlockCard(record.item, view, this.viewContainerRef, this.viewContext);	6✔
73	newContexts.push(context);	6✔
74	newViews.push(view);	6✔
75	newBlockCards.push(blockCard);	6✔
76	mountOnItemChange(record.currentIndex, record.item, newViews, newBlockCards, outletElement, this.viewContext);	6✔
77	} else {
78	const previousView = this.views[record.previousIndex];	53✔
79	const previousViewType = this.viewTypes[record.previousIndex];	53✔
80	const previousContext = this.contexts[record.previousIndex];	53✔
81	const previousBlockCard = this.blockCards[record.previousIndex];	53✔
82	if (previousViewType !== viewType) {	53!
83	view = createEmbeddedViewOrComponent(viewType, context, this.viewContext, this.viewContainerRef);	×
84	blockCard = createBlockCard(record.item, view, this.viewContainerRef, this.viewContext);	×
85	const firstRootNode = getRootNodes(previousView, previousBlockCard)[0];	×
86	const newRootNodes = getRootNodes(view, blockCard);	×
87	firstRootNode.replaceWith(...newRootNodes);	×
88	previousView.destroy();	×
89	previousBlockCard?.destroy();	×
90	} else {
91	view = previousView;	53✔
92	blockCard = previousBlockCard;	53✔
93	if (memoizedContext(this.viewContext, record.item, previousContext as any, context as any)) {	53✔
94	context = previousContext;	37✔
95	} else {
96	updateContext(previousView, context, this.viewContext);	16✔
97	}
98	}
99	newContexts.push(context);	53✔
100	newViews.push(view);	53✔
101	newBlockCards.push(blockCard);	53✔
102	}
103	});
104	diffResult.forEachOperation((record) => {	25✔
105	// removed
106	if (record.currentIndex === null) {	17✔
107	const view = this.views[record.previousIndex];	5✔
108	const blockCard = this.blockCards[record.previousIndex];	5✔
109	view.destroy();	5✔
110	blockCard?.destroy();	5✔
111	}
112	// moved
113	if (record.previousIndex !== null && record.currentIndex !== null) {	17✔
114	mountOnItemChange(record.currentIndex, record.item, newViews, newBlockCards, outletElement, this.viewContext);	6✔
115	// Solve the block-card DOMElement loss when moving nodes
116	newBlockCards[record.currentIndex]?.instance.append();	6✔
117	}
118	});
119	this.viewTypes = newViewTypes;	25✔
120	this.views = newViews;	25✔
121	this.contexts = newContexts;	25✔
122	this.children = children;	25✔
123	this.blockCards = newBlockCards;	25✔
124	} else {
125	const newContexts = [];	12✔
126	this.children.forEach((child, index) => {	12✔
127	let context = getContext(index, child, parentPath, childrenContext, this.viewContext);	61✔
128	const previousContext = this.contexts[index];	61✔
129	if (memoizedContext(this.viewContext, child, previousContext as any, context as any)) {	61✔
130	context = previousContext;	52✔
131	} else {
132	updateContext(this.views[index], context, this.viewContext);	9✔
133	}
134	newContexts.push(context);	61✔
135	});
136	this.contexts = newContexts;	12✔
137	}
138	}
139	}
140
141	export function getContext(
142	index: number,
143	item: Descendant,
144	parentPath: Path,
145	childrenContext: SlateChildrenContext,
146	viewContext: SlateViewContext
147	): SlateElementContext \| SlateTextContext {
148	if (Element.isElement(item)) {	439✔
149	const computedContext = getCommonContext(index, item, parentPath, viewContext, childrenContext);	289✔
150	const key = AngularEditor.findKey(viewContext.editor, item);	289✔
151	const isInline = viewContext.editor.isInline(item);	289✔
152	const isVoid = viewContext.editor.isVoid(item);	289✔
153	const elementContext: SlateElementContext = {	289✔
154	element: item,
155	...computedContext,
156	attributes: {
157	'data-slate-node': 'element',
158	'data-slate-key': key.id
159	},
160	decorate: childrenContext.decorate,
161	readonly: childrenContext.readonly
162	};
163	if (isInline) {	289!
164	elementContext.attributes['data-slate-inline'] = true;	×
165	}
166	if (isVoid) {	289✔
167	elementContext.attributes['data-slate-void'] = true;	1✔
168	elementContext.attributes.contenteditable = false;	1✔
169	}
170	return elementContext;	289✔
171	} else {
172	const computedContext = getCommonContext(index, item, parentPath, viewContext, childrenContext);	150✔
173	const isLeafBlock = AngularEditor.isLeafBlock(viewContext.editor, childrenContext.parent);	150✔
174	const textContext: SlateTextContext = {	150✔
175	decorations: computedContext.decorations,
176	isLast: isLeafBlock && index === childrenContext.parent.children.length - 1,	300✔
177	parent: childrenContext.parent as Element,
178	text: item
179	};
180	return textContext;	150✔
181	}
182	}
183
184	export function getCommonContext(
185	index: number,
186	item: Descendant,
187	parentPath: Path,
188	viewContext: SlateViewContext,
189	childrenContext: SlateChildrenContext
190	): { selection: Range; decorations: Range[] } {
191	const p = parentPath.concat(index);	439✔
192	try {	439✔
193	const ds = childrenContext.decorate([item, p]);	439✔
194	// [list-render] performance optimization: reduce the number of calls to the `Editor.range(viewContext.editor, p)` method
195	if (childrenContext.selection \|\| childrenContext.decorations.length > 0) {	439✔
196	const range = Editor.range(viewContext.editor, p);	73✔
197	const sel = childrenContext.selection && Range.intersection(range, childrenContext.selection);	73✔
198	for (const dec of childrenContext.decorations) {	73✔
199	const d = Range.intersection(dec, range);	6✔
200	if (d) {	6✔
201	ds.push(d);	6✔
202	}
203	}
204	return { selection: sel, decorations: ds };	73✔
205	} else {
206	return { selection: null, decorations: ds };	366✔
207	}
208	} catch (error) {
209	this.options.viewContext.editor.onError({	×
210	code: SlateErrorCode.GetStartPointError,
211	nativeError: error
212	});
213	return { selection: null, decorations: [] };	×
214	}
215	}
216
217	export function getViewType(item: Descendant, parent: Ancestor, viewContext: SlateViewContext) {
218	if (Element.isElement(item)) {	378✔
219	return (viewContext.renderElement && viewContext.renderElement(item)) \|\| viewContext.defaultElement;	234!
220	} else {
221	const isVoid = viewContext.editor.isVoid(parent as Element);	144✔
222	return isVoid ? viewContext.defaultVoidText : (viewContext.renderText && viewContext.renderText(item)) \|\| viewContext.defaultText;	144!
223	}
224	}
225
226	export function createBlockCard(item: Descendant, view: EmbeddedViewRef<any> \| ComponentRef<any>, viewContainerRef: ViewContainerRef, viewContext: SlateViewContext) {
227	const isBlockCard = viewContext.editor.isBlockCard(item);	325✔
228	if (isBlockCard) {	325✔
229	const rootNodes = getRootNodes(view);	1✔
230	const blockCardComponentRef = viewContainerRef.createComponent<SlateBlockCard>(SlateBlockCard, {	1✔
231	injector: viewContainerRef.injector
232	});
233	blockCardComponentRef.instance.initializeCenter(rootNodes);	1✔
234	return blockCardComponentRef;	1✔
235	} else {
236	return null;	324✔
237	}
238	}
239
240	export function trackBy(viewContext: SlateViewContext) {
241	return (index, node) => {	204✔
242	return viewContext.trackBy(node) \|\| AngularEditor.findKey(viewContext.editor, node);	439✔
243	};
244	}
245
246	export function memoizedContext(
247	viewContext: SlateViewContext,
248	descendant: Descendant,
249	prev: SlateElementContext \| SlateTextContext,
250	next: SlateElementContext \| SlateTextContext
251	): boolean {
252	if (Element.isElement(descendant)) {	114✔
253	return memoizedElementContext(viewContext, prev as SlateElementContext, next as SlateElementContext);	105✔
254	} else {
255	return memoizedTextContext(prev as SlateTextContext, next as SlateTextContext);	9✔
256	}
257	}
258
259	export function memoizedElementContext(viewContext: SlateViewContext, prev: SlateElementContext, next: SlateElementContext) {
260	return (	105✔
261	prev.element === next.element &&	559!
262	(!viewContext.isStrictDecorate \|\| prev.decorate === next.decorate) &&
263	prev.readonly === next.readonly &&
264	isDecoratorRangeListEqual(prev.decorations, next.decorations) &&
265	(prev.selection === next.selection \|\| (!!prev.selection && !!next.selection && Range.equals(prev.selection, next.selection)))
266	);
267	}
268
269	export function memoizedTextContext(prev: SlateTextContext, next: SlateTextContext) {
270	return (	9✔
271	next.parent === prev.parent &&	27✔
272	next.isLast === prev.isLast &&
273	next.text === prev.text &&
274	isDecoratorRangeListEqual(next.decorations, prev.decorations)
275	);
276	}

worktile / slate-angular / 23ae19c0-0cd4-4c43-a253-faadd5039d91

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous