41a4291e-3cc3-4434-8b1f-121d287d6fed

Committed 04 Mar 2024 07:06AM UTC coverage: 28.652% (-0.04%) from 28.692%

Build # 41a4291e-3cc3-4434-8b1f-121d287d6fed

Build Type

push

circleci

Committed by

pubuzhixing8

Commit Message

fix(list-render): filter template's root nodes by slate mark

Run Details

186 of 1015 branches covered (18.33%)

Branch coverage included in aggregate %.

0 of 2 new or added lines in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

630 of 1833 relevant lines covered (34.37%)

3.02 hits per line

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

48.39

/packages/src/view/render/utils.ts

import { Descendant } from 'slate';
import { ComponentRef, EmbeddedViewRef, ViewContainerRef } from '@angular/core';
import { ViewType } from '../../types/view';
import { isComponentType, isTemplateRef } from '../../utils/view';
import { SlateElementContext, SlateLeafContext, SlateTextContext, SlateViewContext } from '../context';
import { SlateBlockCard } from '../../components/block-card/block-card.component';

export function createEmbeddedViewOrComponent(
    viewType: ViewType,
    context: any,
    viewContext: SlateViewContext,
    viewContainerRef: ViewContainerRef
) {
    if (isTemplateRef(viewType)) {
        const embeddedViewContext = {
            context,
            viewContext
        };
        const embeddedViewRef = viewContainerRef.createEmbeddedView<any>(viewType, embeddedViewContext);
        embeddedViewRef.detectChanges();
        return embeddedViewRef;
    }
    if (isComponentType(viewType)) {
        const componentRef = viewContainerRef.createComponent(viewType, {
            injector: viewContainerRef.injector
        }) as ComponentRef<any>;
        componentRef.instance.viewContext = viewContext;
        componentRef.instance.context = context;
        componentRef.changeDetectorRef.detectChanges();
        return componentRef;
    }
}

export function renderView(view: EmbeddedViewRef<any> | ComponentRef<any>) {
    if (view instanceof ComponentRef) {
        view.changeDetectorRef.detectChanges();
    } else {
        view.detectChanges();
    }
}

export function updateContext(
    view: EmbeddedViewRef<any> | ComponentRef<any>,
    newContext: SlateElementContext | SlateTextContext | SlateLeafContext,
    viewContext: SlateViewContext
) {
    if (view instanceof ComponentRef) {
        view.instance.context = newContext;
    } else {
        const embeddedViewContext = {
            context: newContext,
            viewContext
        };
        view.context = embeddedViewContext;
        view.detectChanges();
    }
}

export function mount(
    views: (EmbeddedViewRef<any> | ComponentRef<any>)[],
    blockCards: (ComponentRef<SlateBlockCard> | null)[] | null,
    outletParent: HTMLElement,
    outletElement: HTMLElement | null
) {
    if (views.length > 0) {
        const fragment = document.createDocumentFragment();
        views.forEach((view, index) => {
            const blockCard = blockCards ? blockCards[index] : undefined;
            fragment.append(...getRootNodes(view, blockCard));
        });
        if (outletElement) {
            outletElement.parentElement.insertBefore(fragment, outletElement);
            outletElement.remove();
        } else {
            outletParent.prepend(fragment);
        }
    }
}

export function getRootNodes(ref: EmbeddedViewRef<any> | ComponentRef<any>, blockCard?: ComponentRef<SlateBlockCard>): HTMLElement[] {
    if (blockCard) {
        return [blockCard.instance.nativeElement];
    }
    if (ref instanceof ComponentRef) {
        ((ref.hostView as any).rootNodes as (HTMLElement | any)[]).forEach(ele => {
            if (!(ele instanceof HTMLElement)) {
                ele.remove();
            }
        });
        return [ref.instance.nativeElement];
    } else {
        const result: HTMLElement[] = [];
        ref.rootNodes.forEach(rootNode => {
            const isHTMLElement = rootNode instanceof HTMLElement;
            const isSlateNodeOfLeaf =
                isHTMLElement && (rootNode.hasAttribute('data-slate-node') || rootNode.hasAttribute('data-slate-leaf'));
            if (isSlateNodeOfLeaf && result.every(item => !item.contains(rootNode))) {
                result.push(rootNode);
            }
            if (!isHTMLElement) {
                rootNode.remove();
            }
        });
        return result;
    }
}

export function mountOnItemChange(
    index: number,
    item: Descendant,
    views: (EmbeddedViewRef<any> | ComponentRef<any>)[],
    blockCards: (ComponentRef<SlateBlockCard> | null)[] | null,
    outletParent: HTMLElement,
    firstRootNode: HTMLElement | null,
    viewContext: SlateViewContext
) {
    const view = views[index];
    let rootNodes = getRootNodes(view);
    if (blockCards) {
        const isBlockCard = viewContext.editor.isBlockCard(item);
        if (isBlockCard) {
            const blockCard = blockCards[index];
            rootNodes = [blockCard.instance.nativeElement];
        }
    }
    if (index === 0) {
        if (firstRootNode) {
            rootNodes.forEach(rootNode => {
                firstRootNode.insertAdjacentElement('beforebegin', rootNode);
            });
        } else {
            outletParent.prepend(...rootNodes);
        }
    } else {
        const previousView = views[index - 1];
        const blockCard = blockCards ? blockCards[index - 1] : null;
        const previousRootNodes = getRootNodes(previousView, blockCard);
        let previousRootNode = previousRootNodes[previousRootNodes.length - 1];
        rootNodes.forEach(rootNode => {
            previousRootNode.insertAdjacentElement('afterend', rootNode);
            previousRootNode = rootNode;
        });
    }
}

1	import { Descendant } from 'slate';
2	import { ComponentRef, EmbeddedViewRef, ViewContainerRef } from '@angular/core';
3	import { ViewType } from '../../types/view';
4	import { isComponentType, isTemplateRef } from '../../utils/view';
5	import { SlateElementContext, SlateLeafContext, SlateTextContext, SlateViewContext } from '../context';
6	import { SlateBlockCard } from '../../components/block-card/block-card.component';
7
8	export function createEmbeddedViewOrComponent(
9	viewType: ViewType,
10	context: any,
11	viewContext: SlateViewContext,
12	viewContainerRef: ViewContainerRef
13	) {
14	if (isTemplateRef(viewType)) {	29!
15	const embeddedViewContext = {	×
16	context,
17	viewContext
18	};
19	const embeddedViewRef = viewContainerRef.createEmbeddedView<any>(viewType, embeddedViewContext);	×
20	embeddedViewRef.detectChanges();	×
21	return embeddedViewRef;	×
22	}
23	if (isComponentType(viewType)) {	29✔
24	const componentRef = viewContainerRef.createComponent(viewType, {	29✔
25	injector: viewContainerRef.injector
26	}) as ComponentRef<any>;
27	componentRef.instance.viewContext = viewContext;	29✔
28	componentRef.instance.context = context;	29✔
29	componentRef.changeDetectorRef.detectChanges();	29✔
30	return componentRef;	29✔
31	}
32	}
33
34	export function renderView(view: EmbeddedViewRef<any> \| ComponentRef<any>) {
35	if (view instanceof ComponentRef) {	×
36	view.changeDetectorRef.detectChanges();	×
37	} else {
38	view.detectChanges();	×
39	}
40	}
41
42	export function updateContext(
43	view: EmbeddedViewRef<any> \| ComponentRef<any>,
44	newContext: SlateElementContext \| SlateTextContext \| SlateLeafContext,
45	viewContext: SlateViewContext
46	) {
47	if (view instanceof ComponentRef) {	1!
48	view.instance.context = newContext;	1✔
49	} else {
50	const embeddedViewContext = {	×
51	context: newContext,
52	viewContext
53	};
54	view.context = embeddedViewContext;	×
55	view.detectChanges();	×
56	}
57	}
58
59	export function mount(
60	views: (EmbeddedViewRef<any> \| ComponentRef<any>)[],
61	blockCards: (ComponentRef<SlateBlockCard> \| null)[] \| null,
62	outletParent: HTMLElement,
63	outletElement: HTMLElement \| null
64	) {
65	if (views.length > 0) {	23✔
66	const fragment = document.createDocumentFragment();	23✔
67	views.forEach((view, index) => {	23✔
68	const blockCard = blockCards ? blockCards[index] : undefined;	28✔
69	fragment.append(...getRootNodes(view, blockCard));	28✔
70	});
71	if (outletElement) {	23✔
72	outletElement.parentElement.insertBefore(fragment, outletElement);	2✔
73	outletElement.remove();	2✔
74	} else {
75	outletParent.prepend(fragment);	21✔
76	}
77	}
78	}
79
80	export function getRootNodes(ref: EmbeddedViewRef<any> \| ComponentRef<any>, blockCard?: ComponentRef<SlateBlockCard>): HTMLElement[] {
81	if (blockCard) {	33!
82	return [blockCard.instance.nativeElement];	×
83	}
84	if (ref instanceof ComponentRef) {	33!
85	((ref.hostView as any).rootNodes as (HTMLElement \| any)[]).forEach(ele => {	33✔
86	if (!(ele instanceof HTMLElement)) {	117✔
87	ele.remove();	42✔
88	}
89	});
90	return [ref.instance.nativeElement];	33✔
91	} else {
92	const result: HTMLElement[] = [];	×
93	ref.rootNodes.forEach(rootNode => {	×
94	const isHTMLElement = rootNode instanceof HTMLElement;	×
95	const isSlateNodeOfLeaf =
NEW 96	isHTMLElement && (rootNode.hasAttribute('data-slate-node') \|\| rootNode.hasAttribute('data-slate-leaf'));	×
NEW 97	if (isSlateNodeOfLeaf && result.every(item => !item.contains(rootNode))) {	×
UNCOV 98	result.push(rootNode);	×
99	}
100	if (!isHTMLElement) {	×
101	rootNode.remove();	×
102	}
103	});
104	return result;	×
105	}
106	}
107
108	export function mountOnItemChange(
109	index: number,
110	item: Descendant,
111	views: (EmbeddedViewRef<any> \| ComponentRef<any>)[],
112	blockCards: (ComponentRef<SlateBlockCard> \| null)[] \| null,
113	outletParent: HTMLElement,
114	firstRootNode: HTMLElement \| null,
115	viewContext: SlateViewContext
116	) {
117	const view = views[index];	2✔
118	let rootNodes = getRootNodes(view);	2✔
119	if (blockCards) {	2✔
120	const isBlockCard = viewContext.editor.isBlockCard(item);	2✔
121	if (isBlockCard) {	2!
122	const blockCard = blockCards[index];	×
123	rootNodes = [blockCard.instance.nativeElement];	×
124	}
125	}
126	if (index === 0) {	2!
127	if (firstRootNode) {	2!
128	rootNodes.forEach(rootNode => {	2✔
129	firstRootNode.insertAdjacentElement('beforebegin', rootNode);	2✔
130	});
131	} else {
132	outletParent.prepend(...rootNodes);	×
133	}
134	} else {
135	const previousView = views[index - 1];	×
136	const blockCard = blockCards ? blockCards[index - 1] : null;	×
137	const previousRootNodes = getRootNodes(previousView, blockCard);	×
138	let previousRootNode = previousRootNodes[previousRootNodes.length - 1];	×
139	rootNodes.forEach(rootNode => {	×
140	previousRootNode.insertAdjacentElement('afterend', rootNode);	×
141	previousRootNode = rootNode;	×
142	});
143	}
144	}

worktile / slate-angular / 41a4291e-3cc3-4434-8b1f-121d287d6fed

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