12064400667

Committed 28 Nov 2024 07:31AM UTC coverage: 82.655% (-0.2%) from 82.888%

Build # 12064400667

Build Type

Pull #901

github

Committed by

web-flow

Commit Message

Merge 3a09b3759 into c106ab483

Pull Request Pull Request #901: feat: add CrossFlicking Preset

Run Details

4778 of 7694 branches covered (62.1%)

Branch coverage included in aggregate %.

386 of 439 new or added lines in 12 files covered. (87.93%)

3 existing lines in 1 file now uncovered.

11991 of 12594 relevant lines covered (95.21%)

277.48 hits per line

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

68.66

/packages/react-flicking/src/react-flicking/Flicking.tsx

/*
 * Copyright (c) 2015 NAVER Corp.
 * egjs projects are licensed under the MIT license
 */
import * as React from "react";
import Component from "@egjs/component";
import ListDiffer, { diff, DiffResult } from "@egjs/list-differ";
import VanillaFlicking, {
  FlickingOptions,
  VirtualRenderingStrategy,
  EVENTS,
  withFlickingMethods,
  sync,
  getRenderingPanels,
  getDefaultCameraTransform,
  Plugin,
  range,
  NormalRenderingStrategy,
  FlickingEvents,
} from "@egjs/flicking";

import { DEFAULT_PROPS } from "./consts";
import { FlickingProps } from "./types";
import ReactRenderer, { ReactRendererOptions } from "./ReactRenderer";
import StrictPanel from "./StrictPanel";
import NonStrictPanel from "./NonStrictPanel";
import ViewportSlot from "./ViewportSlot";
import ReactElementProvider from "./ReactElementProvider";

class Flicking extends React.Component<Partial<FlickingProps & FlickingOptions>> {
  public static defaultProps: FlickingProps = DEFAULT_PROPS;

  @withFlickingMethods protected _vanillaFlicking: VanillaFlicking;
  private _panels: React.RefObject<StrictPanel | NonStrictPanel | HTMLDivElement>[] = [];
  protected _pluginsDiffer: ListDiffer<any>;
  protected _jsxDiffer: ListDiffer<React.ReactElement>;
  protected _viewportElement: HTMLElement;
  private _diffResult: DiffResult<React.ReactElement> | null;
  private _renderEmitter = new Component<{ render: void }>();
  protected _prevChildren: React.ReactElement[];

  public get reactPanels() { return this._panels.map(panel => panel.current!); }
  public get renderEmitter() { return this._renderEmitter; }

  public constructor(props: Partial<FlickingProps & FlickingOptions>) {
    super(props);

    const children = this._getChildren();
    this._panels = this._createPanelRefs(props, children);
    this._prevChildren = children;
  }

  public componentDidMount() {
    const props = this.props as Required<FlickingProps & FlickingOptions>;
    const rendererOptions: ReactRendererOptions = {
      reactFlicking: this,
      align: props.align,
      strategy: props.virtual && props.panelsPerView > 0
        ? new VirtualRenderingStrategy()
        : new NormalRenderingStrategy({
          providerCtor: ReactElementProvider
        })
    };

    const flicking = new VanillaFlicking(
      this._viewportElement,
      {
        ...props,
        externalRenderer: new ReactRenderer(rendererOptions)
      },
    );

    this._vanillaFlicking = flicking;

    const children = this._getChildren();
    this._jsxDiffer = new ListDiffer(children, panel => panel.key!);
    this._pluginsDiffer = new ListDiffer<any>();
    this._prevChildren = children;

    this._bindEvents();
    this._checkPlugins();

    if (props.status) {
      flicking.setStatus(props.status);
    }
  }

  public componentWillUnmount() {
    this._vanillaFlicking?.destroy();
  }

  public shouldComponentUpdate(nextProps: Readonly<Partial<FlickingProps & FlickingOptions>>): boolean {
    const vanillaFlicking = this._vanillaFlicking;
    const prevProps = this.props;

    if (!vanillaFlicking || !vanillaFlicking.initialized) return false;

    const { children, ...restProps } = nextProps;

    for (const key in restProps) {
      if (prevProps[key] !== nextProps[key]) {
        return true;
      }
    }

    const prevChildren = this._prevChildren;
    const nextChildren = this._getChildren(children);
    if (nextProps.renderOnSameKey || !this._hasSameChildren(prevChildren, nextChildren)) return true;

    return false;
  }

  public beforeRender() {
    const vanillaFlicking = this._vanillaFlicking;
    const props = this.props;
    const prevChildren = this._prevChildren;

    // Ignore updates before init, they will be updated after "ready" event's force update
    // Also, prevent updates when another update is already queued.
    // This usually happens when render() called twice without calling componentDidMount, like in the case of React.StrictMode.
    if (!vanillaFlicking || !vanillaFlicking.initialized || this._diffResult) return;

    const nextChildren = this._getChildren(props.children);
    if (props.renderOnSameKey || !this._hasSameChildren(prevChildren, nextChildren)) {
      this._panels = this._createPanelRefs(props, nextChildren);
      this._diffResult = this._jsxDiffer.update(nextChildren);
      this._prevChildren = nextChildren;
    }
  }

  public componentDidUpdate() {
    const flicking = this._vanillaFlicking;
    const renderEmitter = this._renderEmitter;
    const diffResult = this._diffResult;

    this._checkPlugins();
    renderEmitter.trigger("render");
    flicking.camera.updateOffset();

    // Omit 'virtual', as it can't have any setter
    const { virtual, ...props } = this.props;
    for (const key in props) {
      if (key in flicking && flicking[key] !== props[key]) {
        flicking[key] = props[key];
      }
    }

    if (!diffResult || !flicking.initialized) return;

    sync(flicking, diffResult, this.reactPanels);

    this._diffResult = null;
  }

  public render() {
    const props = this.props;
    const Viewport = props.viewportTag as any;
    const Camera = props.cameraTag as any;
    const attributes: { [key: string]: any } = {};

    this.beforeRender();

    for (const name in props) {
      if (!(name in DEFAULT_PROPS) && !(name in VanillaFlicking.prototype)) {
        attributes[name] = props[name];
      }
    }

    const { viewportClasses, cameraClasses, cameraProps } = this._getClasses(attributes, props);

    const panels = !!props.virtual && (props.panelsPerView ?? -1) > 0
      ? this._getVirtualPanels()
      : this._getPanels();

    return (
      <Viewport {...attributes} className={viewportClasses.join(" ")} ref={(e?: HTMLElement) => {
        e && (this._viewportElement = e);
      }}>
        <Camera className={cameraClasses.join(" ")} {...cameraProps}>
          { panels }
        </Camera>
        { this._getViewportSlot() }
      </Viewport>
    );
  }

  private _createPanelRefs(props: this["props"], children: Array<React.ReactElement<any>>): React.RefObject<StrictPanel | NonStrictPanel | HTMLDivElement>[] {
    const panelsPerView = props.panelsPerView ?? -1;

    return panelsPerView > 0 && !!props.virtual
      ? range(panelsPerView + 1).map(() => React.createRef())
      : children.map(() => React.createRef());
  }

  protected _bindEvents() {
    const flicking = this._vanillaFlicking!;

    Object.keys(EVENTS).forEach((eventKey: keyof typeof EVENTS) => {
      const eventName = EVENTS[eventKey];
      this._bindEvent(eventName);
    });

    flicking.once(EVENTS.READY, () => {
      this.forceUpdate();
    });
  }

  protected _bindEvent(eventName: keyof FlickingEvents) {
    const propName = `on${eventName.charAt(0).toUpperCase() + eventName.slice(1)}`;

    this._vanillaFlicking!.on(eventName, e => {
      e.currentTarget = this;

      const evtHandler = this.props[propName];
      evtHandler(e);
    });
  }

  protected _checkPlugins() {
    const flicking = this._vanillaFlicking;
    const { list, added, removed, prevList } = this._pluginsDiffer.update(this.props.plugins!) as DiffResult<Plugin>;

    flicking.addPlugins(...added.map(index => list[index]));
    flicking.removePlugins(...removed.map(index => prevList[index]));
  }

  protected _getClasses(attributes: { [key: string]: any }, props: typeof this.props) {
    const flicking = this._vanillaFlicking;

    const initialized = flicking && flicking.initialized;
    const viewportClasses: string[] = ["flicking-viewport"];
    const cameraClasses: string[] = ["flicking-camera"];
    const isHorizontal = flicking
      ? flicking.horizontal
      : props.horizontal ?? true;

    if (!isHorizontal) {
      viewportClasses.push("vertical");
    }
    if (props.hideBeforeInit && !initialized) {
      viewportClasses.push("flicking-hidden");
    }
    if (attributes.className) {
      viewportClasses.push(attributes.className);
    }
    if (props.cameraClass) {
      cameraClasses.push(props.cameraClass);
    }

    const cameraProps = !initialized && props.firstPanelSize
      ? { style: {
        transform: getDefaultCameraTransform(this.props.align, this.props.horizontal, this.props.firstPanelSize)
      }}
      : {};

    return {
      viewportClasses,
      cameraClasses,
      cameraProps,
    };
  }

  private _hasSameChildren(prevChildren: React.ReactElement[], nextChildren: React.ReactElement[]) {
    if (prevChildren.length !== nextChildren.length || prevChildren.length === 0) return false;

    const same = prevChildren.every((child, idx) => {
      const nextChild = nextChildren[idx];

      if (child.key && nextChild.key) {
        return child.key === nextChild.key;
      } else {
        return child === nextChild;
      }
    });

    return same;
  }

  protected _getChildren(children: React.ReactNode = this.props.children) {
    return (React.Children.toArray(children) as Array<React.ReactElement<any>>)
      .filter(child => child.type !== ViewportSlot)
      .reduce((all, child) => {
        return [...all, ...this._unpackFragment(child)];
      }, []) as Array<React.ReactElement<any>>;
  }

  protected _getViewportSlot() {
    return (React.Children.toArray(this.props.children) as Array<React.ReactElement<any>>)
      .filter(child => child.type === ViewportSlot);
  }

  private _unpackFragment(child: React.ReactElement) {
    return this._isFragment(child)
      ? React.Children.toArray(child.props.children)
        .reduce((allChilds: React.ReactElement[], fragChild: React.ReactElement) => [...allChilds, ...this._unpackFragment(fragChild)], [] as React.ReactElement[])
      : [child];
  }

  private _getVirtualPanels() {
    const {
      panelClass = "flicking-panel"
    } = this.props.virtual!;
    const panelsPerView = this.props.panelsPerView!;
    const flicking = this._vanillaFlicking;
    const initialized = flicking && flicking.initialized;

    const renderingIndexes = initialized
      ? flicking.renderer.strategy.getRenderingIndexesByOrder(flicking)
      : range(panelsPerView + 1);

    const firstPanel = flicking && flicking.panels[0];
    const size = firstPanel
      ? flicking.horizontal
        ? { width: firstPanel.size }
        : { height: firstPanel.size }
      : {};

    return renderingIndexes.map(idx => {
      return <div
        key={idx}
        data-element-index={idx}
        ref={this._panels[idx] as React.RefObject<HTMLDivElement>}
        className={panelClass}
        style={size} />
    });
  }

  protected _getPanels() {
    const origChildren = this._getChildren();
    const vanillaFlicking = this._vanillaFlicking;
    const diffResult = this._diffResult;

    const children: React.ReactElement[] = vanillaFlicking && vanillaFlicking.initialized
      ? diffResult
        ? getRenderingPanels(vanillaFlicking, diffResult)
        : getRenderingPanels(vanillaFlicking, diff(origChildren, origChildren))
      : origChildren;

    return this.props.useFindDOMNode
      ? children.map((child, idx) => <NonStrictPanel key={child.key!} ref={this._panels[idx] as any}>{child}</NonStrictPanel>)
      : children.map((child, idx) => <StrictPanel key={child.key!} ref={this._panels[idx] as any}>{child}</StrictPanel>)
  }

  private _isFragment(child: React.ReactElement) {
    if (child.type) {
      return child.type === React.Fragment;
    }

    return (child as any) === React.Fragment;
  }
}

interface Flicking extends React.Component<Partial<FlickingProps & FlickingOptions>>, VanillaFlicking { }
export default Flicking;

1	/*
2	* Copyright (c) 2015 NAVER Corp.
3	* egjs projects are licensed under the MIT license
4	*/
5	import * as React from "react";	5✔
6	import Component from "@egjs/component";	5✔
7	import ListDiffer, { diff, DiffResult } from "@egjs/list-differ";	5✔
8	import VanillaFlicking, {	5✔
9	FlickingOptions,
10	VirtualRenderingStrategy,
11	EVENTS,
12	withFlickingMethods,
13	sync,
14	getRenderingPanels,
15	getDefaultCameraTransform,
16	Plugin,
17	range,
18	NormalRenderingStrategy,
19	FlickingEvents,
20	} from "@egjs/flicking";
21
22	import { DEFAULT_PROPS } from "./consts";	5✔
23	import { FlickingProps } from "./types";
24	import ReactRenderer, { ReactRendererOptions } from "./ReactRenderer";	5✔
25	import StrictPanel from "./StrictPanel";	5✔
26	import NonStrictPanel from "./NonStrictPanel";	5✔
27	import ViewportSlot from "./ViewportSlot";	5✔
28	import ReactElementProvider from "./ReactElementProvider";	5✔
29
30	class Flicking extends React.Component<Partial<FlickingProps & FlickingOptions>> {	5✔
31	public static defaultProps: FlickingProps = DEFAULT_PROPS;	5✔
32
33	@withFlickingMethods protected _vanillaFlicking: VanillaFlicking;	5✔
34	private _panels: React.RefObject<StrictPanel \| NonStrictPanel \| HTMLDivElement>[] = [];	14✔
35	protected _pluginsDiffer: ListDiffer<any>;
36	protected _jsxDiffer: ListDiffer<React.ReactElement>;
37	protected _viewportElement: HTMLElement;
38	private _diffResult: DiffResult<React.ReactElement> \| null;
39	private _renderEmitter = new Component<{ render: void }>();	14✔
40	protected _prevChildren: React.ReactElement[];
41
42	public get reactPanels() { return this._panels.map(panel => panel.current!); }	54✔
43	public get renderEmitter() { return this._renderEmitter; }	49✔
44
45	public constructor(props: Partial<FlickingProps & FlickingOptions>) {
46	super(props);	14✔
47
48	const children = this._getChildren();	14✔
49	this._panels = this._createPanelRefs(props, children);	14✔
50	this._prevChildren = children;	14✔
51	}
52
53	public componentDidMount() {	5✔
54	const props = this.props as Required<FlickingProps & FlickingOptions>;	14✔
55	const rendererOptions: ReactRendererOptions = {	14✔
56	reactFlicking: this,
57	align: props.align,
58	strategy: props.virtual && props.panelsPerView > 0	28!
59	? new VirtualRenderingStrategy()
60	: new NormalRenderingStrategy({
61	providerCtor: ReactElementProvider
62	})
63	};
64
65	const flicking = new VanillaFlicking(	14✔
66	this._viewportElement,
67	{
68	...props,
69	externalRenderer: new ReactRenderer(rendererOptions)
70	},
71	);
72
73	this._vanillaFlicking = flicking;	14✔
74
75	const children = this._getChildren();	14✔
76	this._jsxDiffer = new ListDiffer(children, panel => panel.key!);	14✔
77	this._pluginsDiffer = new ListDiffer<any>();	14✔
78	this._prevChildren = children;	14✔
79
80	this._bindEvents();	14✔
81	this._checkPlugins();	14✔
82
83	if (props.status) {	14!
84	flicking.setStatus(props.status);	×
85	}
86	}
87
88	public componentWillUnmount() {	5✔
89	this._vanillaFlicking?.destroy();	14!
90	}
91
92	public shouldComponentUpdate(nextProps: Readonly<Partial<FlickingProps & FlickingOptions>>): boolean {	5✔
93	const vanillaFlicking = this._vanillaFlicking;	×
94	const prevProps = this.props;	×
95
96	if (!vanillaFlicking \|\| !vanillaFlicking.initialized) return false;	×
97
98	const { children, ...restProps } = nextProps;	×
99
100	for (const key in restProps) {	×
101	if (prevProps[key] !== nextProps[key]) {	×
102	return true;	×
103	}
104	}
105
106	const prevChildren = this._prevChildren;	×
107	const nextChildren = this._getChildren(children);	×
108	if (nextProps.renderOnSameKey \|\| !this._hasSameChildren(prevChildren, nextChildren)) return true;	×
109
110	return false;	×
111	}
112
113	public beforeRender() {	5✔
114	const vanillaFlicking = this._vanillaFlicking;	48✔
115	const props = this.props;	48✔
116	const prevChildren = this._prevChildren;	48✔
117
118	// Ignore updates before init, they will be updated after "ready" event's force update
119	// Also, prevent updates when another update is already queued.
120	// This usually happens when render() called twice without calling componentDidMount, like in the case of React.StrictMode.
121	if (!vanillaFlicking \|\| !vanillaFlicking.initialized \|\| this._diffResult) return;	48✔
122
123	const nextChildren = this._getChildren(props.children);	34✔
124	if (props.renderOnSameKey \|\| !this._hasSameChildren(prevChildren, nextChildren)) {	34!
125	this._panels = this._createPanelRefs(props, nextChildren);	×
126	this._diffResult = this._jsxDiffer.update(nextChildren);	×
127	this._prevChildren = nextChildren;	×
128	}
129	}
130
131	public componentDidUpdate() {	5✔
132	const flicking = this._vanillaFlicking;	34✔
133	const renderEmitter = this._renderEmitter;	34✔
134	const diffResult = this._diffResult;	34✔
135
136	this._checkPlugins();	34✔
137	renderEmitter.trigger("render");	34✔
138	flicking.camera.updateOffset();	34✔
139
140	// Omit 'virtual', as it can't have any setter
141	const { virtual, ...props } = this.props;	34✔
142	for (const key in props) {	34✔
143	if (key in flicking && flicking[key] !== props[key]) {	934!
144	flicking[key] = props[key];	×
145	}
146	}
147
148	if (!diffResult \|\| !flicking.initialized) return;	34!
149
150	sync(flicking, diffResult, this.reactPanels);	×
151
152	this._diffResult = null;	×
153	}
154
155	public render() {	48✔
156	const props = this.props;	48✔
157	const Viewport = props.viewportTag as any;	48✔
158	const Camera = props.cameraTag as any;	48✔
159	const attributes: { [key: string]: any } = {};	48✔
160
161	this.beforeRender();	48✔
162
163	for (const name in props) {	48✔
164	if (!(name in DEFAULT_PROPS) && !(name in VanillaFlicking.prototype)) {	1,317✔
165	attributes[name] = props[name];	96✔
166	}
167	}
168
169	const { viewportClasses, cameraClasses, cameraProps } = this._getClasses(attributes, props);	48✔
170
171	const panels = !!props.virtual && (props.panelsPerView ?? -1) > 0	48!
172	? this._getVirtualPanels()
173	: this._getPanels();
174
175	return (	48✔
176	<Viewport {...attributes} className={viewportClasses.join(" ")} ref={(e?: HTMLElement) => {
177	e && (this._viewportElement = e);	96✔
178	}}>
179	<Camera className={cameraClasses.join(" ")} {...cameraProps}>
180	{ panels }
181	</Camera>
182	{ this._getViewportSlot() }
183	</Viewport>
184	);
185	}
186
187	private _createPanelRefs(props: this["props"], children: Array<React.ReactElement<any>>): React.RefObject<StrictPanel \| NonStrictPanel \| HTMLDivElement>[] {	5✔
188	const panelsPerView = props.panelsPerView ?? -1;	14!
189
190	return panelsPerView > 0 && !!props.virtual	14!
191	? range(panelsPerView + 1).map(() => React.createRef())	×
192	: children.map(() => React.createRef());	54✔
193	}
194
195	protected _bindEvents() {	14✔
196	const flicking = this._vanillaFlicking!;	14✔
197
198	Object.keys(EVENTS).forEach((eventKey: keyof typeof EVENTS) => {	14✔
199	const eventName = EVENTS[eventKey];	238✔
200	this._bindEvent(eventName);	238✔
201	});
202
203	flicking.once(EVENTS.READY, () => {	14✔
204	this.forceUpdate();	14✔
205	});
206	}
207
208	protected _bindEvent(eventName: keyof FlickingEvents) {	238✔
209	const propName = `on${eventName.charAt(0).toUpperCase() + eventName.slice(1)}`;	238✔
210
211	this._vanillaFlicking!.on(eventName, e => {	238✔
212	e.currentTarget = this;	353✔
213
214	const evtHandler = this.props[propName];	353✔
215	evtHandler(e);	353✔
216	});
217	}
218
219	protected _checkPlugins() {	5✔
220	const flicking = this._vanillaFlicking;	48✔
221	const { list, added, removed, prevList } = this._pluginsDiffer.update(this.props.plugins!) as DiffResult<Plugin>;	48✔
222
223	flicking.addPlugins(...added.map(index => list[index]));	48✔
224	flicking.removePlugins(...removed.map(index => prevList[index]));	48✔
225	}
226
227	protected _getClasses(attributes: { [key: string]: any }, props: typeof this.props) {	5✔
228	const flicking = this._vanillaFlicking;	48✔
229
230	const initialized = flicking && flicking.initialized;	48✔
231	const viewportClasses: string[] = ["flicking-viewport"];	48✔
232	const cameraClasses: string[] = ["flicking-camera"];	48✔
233	const isHorizontal = flicking	48✔
234	? flicking.horizontal
235	: props.horizontal ?? true;	42!
236
237	if (!isHorizontal) {	48!
NEW 238	viewportClasses.push("vertical");	×
239	}
240	if (props.hideBeforeInit && !initialized) {	48!
NEW 241	viewportClasses.push("flicking-hidden");	×
242	}
243	if (attributes.className) {	48!
NEW 244	viewportClasses.push(attributes.className);	×
245	}
246	if (props.cameraClass) {	48!
NEW 247	cameraClasses.push(props.cameraClass);	×
248	}
249
250	const cameraProps = !initialized && props.firstPanelSize	48!
251	? { style: {
252	transform: getDefaultCameraTransform(this.props.align, this.props.horizontal, this.props.firstPanelSize)
253	}}
254	: {};
255
256	return {	48✔
257	viewportClasses,
258	cameraClasses,
259	cameraProps,
260	};
261	}
262
263	private _hasSameChildren(prevChildren: React.ReactElement[], nextChildren: React.ReactElement[]) {	5✔
264	if (prevChildren.length !== nextChildren.length \|\| prevChildren.length === 0) return false;	34!
265
266	const same = prevChildren.every((child, idx) => {	34✔
267	const nextChild = nextChildren[idx];	126✔
268
269	if (child.key && nextChild.key) {	126!
270	return child.key === nextChild.key;	126✔
271	} else {
272	return child === nextChild;	×
273	}
274	});
275
276	return same;	34✔
277	}
278
279	protected _getChildren(children: React.ReactNode = this.props.children) {	186✔
280	return (React.Children.toArray(children) as Array<React.ReactElement<any>>)	110✔
281	.filter(child => child.type !== ViewportSlot)	414✔
282	.reduce((all, child) => {
283	return [...all, ...this._unpackFragment(child)];	414✔
284	}, []) as Array<React.ReactElement<any>>;
285	}
286
287	protected _getViewportSlot() {	5✔
288	return (React.Children.toArray(this.props.children) as Array<React.ReactElement<any>>)	48✔
289	.filter(child => child.type === ViewportSlot);	180✔
290	}
291
292	private _unpackFragment(child: React.ReactElement) {	414✔
293	return this._isFragment(child)	414!
294	? React.Children.toArray(child.props.children)
295	.reduce((allChilds: React.ReactElement[], fragChild: React.ReactElement) => [...allChilds, ...this._unpackFragment(fragChild)], [] as React.ReactElement[])	×
296	: [child];
297	}
298
299	private _getVirtualPanels() {	5✔
300	const {
301	panelClass = "flicking-panel"	×
302	} = this.props.virtual!;	×
303	const panelsPerView = this.props.panelsPerView!;	×
304	const flicking = this._vanillaFlicking;	×
305	const initialized = flicking && flicking.initialized;	×
306
307	const renderingIndexes = initialized	×
308	? flicking.renderer.strategy.getRenderingIndexesByOrder(flicking)
309	: range(panelsPerView + 1);
310
311	const firstPanel = flicking && flicking.panels[0];	×
312	const size = firstPanel	×
313	? flicking.horizontal	×
314	? { width: firstPanel.size }
315	: { height: firstPanel.size }
316	: {};
317
318	return renderingIndexes.map(idx => {	×
319	return <div	×
320	key={idx}
321	data-element-index={idx}
322	ref={this._panels[idx] as React.RefObject<HTMLDivElement>}
323	className={panelClass}
324	style={size} />
325	});
326	}
327
328	protected _getPanels() {	48✔
329	const origChildren = this._getChildren();	48✔
330	const vanillaFlicking = this._vanillaFlicking;	48✔
331	const diffResult = this._diffResult;	48✔
332
333	const children: React.ReactElement[] = vanillaFlicking && vanillaFlicking.initialized	48✔
334	? diffResult	34!
335	? getRenderingPanels(vanillaFlicking, diffResult)
336	: getRenderingPanels(vanillaFlicking, diff(origChildren, origChildren))
337	: origChildren;
338
339	return this.props.useFindDOMNode	48!
340	? children.map((child, idx) => <NonStrictPanel key={child.key!} ref={this._panels[idx] as any}>{child}</NonStrictPanel>)	×
341	: children.map((child, idx) => <StrictPanel key={child.key!} ref={this._panels[idx] as any}>{child}</StrictPanel>)	180✔
342	}
343
344	private _isFragment(child: React.ReactElement) {	5✔
345	if (child.type) {	414✔
346	return child.type === React.Fragment;	414✔
347	}
348
349	return (child as any) === React.Fragment;	×
350	}
351	}	5✔
352
353	interface Flicking extends React.Component<Partial<FlickingProps & FlickingOptions>>, VanillaFlicking { }
354	export default Flicking;	5✔

naver / egjs-flicking / 12064400667

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