69fe0099-5d8b-4249-8c40-f33e6ce7f3d6

Committed 20 Nov 2023 07:25AM UTC coverage: 48.5% (+2.4%) from 46.148%

Build # 69fe0099-5d8b-4249-8c40-f33e6ce7f3d6

Build Type

Pull #242

circleci

Committed by

pubuzhixing8

Commit Message

chore: enter prerelease mode

Pull Request Pull Request #242: List render

Run Details

378 of 964 branches covered (0.0%)

Branch coverage included in aggregate %.

284 of 334 new or added lines in 12 files covered. (85.03%)

8 existing lines in 3 files now uncovered.

948 of 1770 relevant lines covered (53.56%)

39.84 hits per line

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

62.03

/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,
    outletElement: HTMLElement
) {
    if (views.length > 0) {
        const result = [];
        views.forEach((view, index) => {
            const blockCard = blockCards ? blockCards[index] : undefined;
            result.push(...getRootNodes(view, blockCard));
        });
        outletElement.append(...result);
    }
}

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;
            if (isHTMLElement && 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,
    outletElement: HTMLElement,
    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) {
        outletElement.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)) {	468!
NEW 15	const embeddedViewContext = {	×
16	context,
17	viewContext
18	};
NEW 19	const embeddedViewRef = viewContainerRef.createEmbeddedView<any>(viewType, embeddedViewContext);	×
NEW 20	embeddedViewRef.detectChanges();	×
NEW 21	return embeddedViewRef;	×
22	}
23	if (isComponentType(viewType)) {	468✔
24	const componentRef = viewContainerRef.createComponent(viewType, {	468✔
25	injector: viewContainerRef.injector
26	}) as ComponentRef<any>;
27	componentRef.instance.viewContext = viewContext;	468✔
28	componentRef.instance.context = context;	468✔
29	componentRef.changeDetectorRef.detectChanges();	468✔
30	return componentRef;	468✔
31	}
32	}
33
34	export function renderView(view: EmbeddedViewRef<any> \| ComponentRef<any>) {
NEW 35	if (view instanceof ComponentRef) {	×
NEW 36	view.changeDetectorRef.detectChanges();	×
37	} else {
NEW 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) {	33!
48	view.instance.context = newContext;	33✔
49	} else {
NEW 50	const embeddedViewContext = {	×
51	context: newContext,
52	viewContext
53	};
NEW 54	view.context = embeddedViewContext;	×
NEW 55	view.detectChanges();	×
56	}
57	}
58
59	export function mount(
60	views: (EmbeddedViewRef<any> \| ComponentRef<any>)[],
61	blockCards: (ComponentRef<SlateBlockCard> \| null)[] \| null,
62	outletElement: HTMLElement
63	) {
64	if (views.length > 0) {	345✔
65	const result = [];	345✔
66	views.forEach((view, index) => {	345✔
67	const blockCard = blockCards ? blockCards[index] : undefined;	460✔
68	result.push(...getRootNodes(view, blockCard));	460✔
69	});
70	outletElement.append(...result);	345✔
71	}
72	}
73
74	export function getRootNodes(ref: EmbeddedViewRef<any> \| ComponentRef<any>, blockCard?: ComponentRef<SlateBlockCard>): HTMLElement[] {
75	if (blockCard) {	484✔
76	return [blockCard.instance.nativeElement];	1✔
77	}
78	if (ref instanceof ComponentRef) {	483!
79	((ref.hostView as any).rootNodes as (HTMLElement \| any)[]).forEach(ele => {	483✔
80	if (!(ele instanceof HTMLElement)) {	2,322✔
81	ele.remove();	865✔
82	}
83	});
84	return [ref.instance.nativeElement];	483✔
85	} else {
NEW 86	const result: HTMLElement[] = [];	×
NEW 87	ref.rootNodes.forEach(rootNode => {	×
NEW 88	const isHTMLElement = rootNode instanceof HTMLElement;	×
NEW 89	if (isHTMLElement && result.every(item => !item.contains(rootNode))) {	×
NEW 90	result.push(rootNode);	×
91	}
NEW 92	if (!isHTMLElement) {	×
NEW 93	rootNode.remove();	×
94	}
95	});
NEW 96	return result;	×
97	}
98	}
99
100	export function mountOnItemChange(
101	index: number,
102	item: Descendant,
103	views: (EmbeddedViewRef<any> \| ComponentRef<any>)[],
104	blockCards: (ComponentRef<SlateBlockCard> \| null)[] \| null,
105	outletElement: HTMLElement,
106	viewContext: SlateViewContext
107	) {
108	const view = views[index];	14✔
109	let rootNodes = getRootNodes(view);	14✔
110	if (blockCards) {	14✔
111	const isBlockCard = viewContext.editor.isBlockCard(item);	12✔
112	if (isBlockCard) {	12!
NEW 113	const blockCard = blockCards[index];	×
NEW 114	rootNodes = [blockCard.instance.nativeElement];	×
115	}
116	}
117	if (index === 0) {	14✔
118	outletElement.prepend(...rootNodes);	5✔
119	} else {
120	const previousView = views[index - 1];	9✔
121	const blockCard = blockCards ? blockCards[index - 1] : null;	9✔
122	const previousRootNodes = getRootNodes(previousView, blockCard);	9✔
123	let previousRootNode = previousRootNodes[previousRootNodes.length - 1];	9✔
124	rootNodes.forEach(rootNode => {	9✔
125	previousRootNode.insertAdjacentElement('afterend', rootNode);	9✔
126	previousRootNode = rootNode;	9✔
127	});
128	}
129	}

worktile / slate-angular / 69fe0099-5d8b-4249-8c40-f33e6ce7f3d6

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