10557177632

Committed 26 Aug 2024 09:22AM UTC coverage: 38.327% (-44.5%) from 82.855%

Build # 10557177632

Build Type

Pull #886

github

Committed by

daybrush

Commit Message

fix: recalculate camera offset

Pull Request Pull Request #886: fix: recalculate camera offset

Run Details

2039 of 7372 branches covered (27.66%)

Branch coverage included in aggregate %.

11 of 29 new or added lines in 2 files covered. (37.93%)

5575 existing lines in 46 files now uncovered.

5099 of 11252 relevant lines covered (45.32%)

10.91 hits per line

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

85.95

/src/renderer/strategy/NormalRenderingStrategy.ts

/*
 * Copyright (c) 2015 NAVER Corp.
 * egjs projects are licensed under the MIT license
 */
import Flicking from "../../Flicking";
import Panel, { PanelOptions } from "../../core/panel/Panel";
import ElementProvider from "../../core/panel/provider/ElementProvider";
import { DIRECTION } from "../../const/external";
import { parsePanelAlign } from "../../utils";

import RenderingStrategy from "./RenderingStrategy";

export interface NormalRenderingStrategyOptions {
  providerCtor: new (...args: any) => ElementProvider;
}


class NormalRenderingStrategy implements RenderingStrategy {
  private _providerCtor: NormalRenderingStrategyOptions["providerCtor"];

  public constructor({ providerCtor }: NormalRenderingStrategyOptions) {
    this._providerCtor = providerCtor;
  }

  public renderPanels() {
    // DO_NOTHING
  }

  public getRenderingIndexesByOrder(flicking: Flicking) {
    const renderedPanels = flicking.renderer.panels.filter(panel => panel.rendered);
    const toggledPrev = renderedPanels.filter(panel => panel.toggled && panel.toggleDirection === DIRECTION.PREV);
    const toggledNext = renderedPanels.filter(panel => panel.toggled && panel.toggleDirection === DIRECTION.NEXT);
    const notToggled = renderedPanels.filter(panel => !panel.toggled);

    return [...toggledPrev, ...notToggled, ...toggledNext].map(panel => panel.index);
  }

  public getRenderingElementsByOrder(flicking: Flicking) {
    const panels = flicking.panels;

    return this.getRenderingIndexesByOrder(flicking).map(index => panels[index].element);
  }

  public updateRenderingPanels(flicking: Flicking) {
    if (flicking.renderOnlyVisible) {
      this._showOnlyVisiblePanels(flicking);
    } else {
      flicking.panels.forEach(panel => panel.markForShow());
    }
  }

  public collectPanels(
    flicking: Flicking,
    elements: any[]
  ) {
    const align = parsePanelAlign(flicking.renderer.align);

    return elements.map((el, index) => new Panel({
      index,
      elementProvider: new this._providerCtor(el),
      align,
      flicking
    }));
  }

  public createPanel(
    element: any,
    options: Omit<PanelOptions, "elementProvider">
  ) {
    return new Panel({
      ...options,
      elementProvider: new this._providerCtor(element)
    });
  }

  public updatePanelSizes(flicking: Flicking, size: Partial<{
    width: number | string;
    height: number | string;
  }>) {
    flicking.panels.forEach(panel => panel.setSize(size));
  }

  private _showOnlyVisiblePanels(flicking: Flicking) {
    const panels = flicking.renderer.panels;
    const camera = flicking.camera;

    const visibleIndexes = camera.visiblePanels.reduce((visibles, panel) => {
      visibles[panel.index] = true;
      return visibles;
    }, {});

    panels.forEach(panel => {
      if (panel.index in visibleIndexes || panel.loading) {
        panel.markForShow();
      } else if (!flicking.holding) {
        // During the input sequence,
        // Do not remove panel elements as it won't trigger touchend event.
        panel.markForHide();
      }
    });

    camera.updateOffset();
  }
}

export default NormalRenderingStrategy;

1	/*	1✔
2	* Copyright (c) 2015 NAVER Corp.	1✔
3	* egjs projects are licensed under the MIT license	×
4	*/
5	import Flicking from "../../Flicking";
6	import Panel, { PanelOptions } from "../../core/panel/Panel";	5!
7	import ElementProvider from "../../core/panel/provider/ElementProvider";
8	import { DIRECTION } from "../../const/external";	5✔
9	import { parsePanelAlign } from "../../utils";	5✔
10
11	import RenderingStrategy from "./RenderingStrategy";
12
13	export interface NormalRenderingStrategyOptions {	1✔
14	providerCtor: new (...args: any) => ElementProvider;	9!
15	}	3!
16		×
17
18	class NormalRenderingStrategy implements RenderingStrategy {	5✔
19	private _providerCtor: NormalRenderingStrategyOptions["providerCtor"];
20		9✔
21	public constructor({ providerCtor }: NormalRenderingStrategyOptions) {	14✔
22	this._providerCtor = providerCtor;	15✔
23	}	1!
24
25	public renderPanels() {	6✔
26	// DO_NOTHING	1✔
27	}	1✔
28		1✔
29	public getRenderingIndexesByOrder(flicking: Flicking) {	6✔
30	const renderedPanels = flicking.renderer.panels.filter(panel => panel.rendered);	129✔
31	const toggledPrev = renderedPanels.filter(panel => panel.toggled && panel.toggleDirection === DIRECTION.PREV);	126!
32	const toggledNext = renderedPanels.filter(panel => panel.toggled && panel.toggleDirection === DIRECTION.NEXT);	126!
33	const notToggled = renderedPanels.filter(panel => !panel.toggled);	125✔
34		1✔
35	return [...toggledPrev, ...notToggled, ...toggledNext].map(panel => panel.index);	125✔
36	}
37		1✔
38	public getRenderingElementsByOrder(flicking: Flicking) {	20✔
39	const panels = flicking.panels;	38!
40		3!
41	return this.getRenderingIndexesByOrder(flicking).map(index => panels[index].element);	128✔
42	}	3✔
43
44	public updateRenderingPanels(flicking: Flicking) {	6✔
45	if (flicking.renderOnlyVisible) {	38✔
46	this._showOnlyVisiblePanels(flicking);	5✔
47	} else {
48	flicking.panels.forEach(panel => panel.markForShow());	124✔
49	}	3!
50	}	3✔
51
52	public collectPanels(	14✔
53	flicking: Flicking,
54	elements: any[]
55	) {
56	const align = parsePanelAlign(flicking.renderer.align);	15✔
57		1✔
58	return elements.map((el, index) => new Panel({	55✔
59	index,	5✔
60	elementProvider: new this._providerCtor(el),
61	align,
62	flicking
63	}));
64	}
65
66	public createPanel(	6✔
67	element: any,
68	options: Omit<PanelOptions, "elementProvider">
69	) {	1✔
UNCOV 70	return new Panel({	×
71	...options,
72	elementProvider: new this._providerCtor(element)	1✔
73	});	3✔
74	}	3✔
75		3✔
76	public updatePanelSizes(flicking: Flicking, size: Partial<{	8✔
77	width: number \| string;	3✔
78	height: number \| string;
79	}>) {	3✔
80	flicking.panels.forEach(panel => panel.setSize(size));	15✔
81	}	3✔
82
83	private _showOnlyVisiblePanels(flicking: Flicking) {	17!
84	const panels = flicking.renderer.panels;	2✔
85	const camera = flicking.camera;	2✔
86		12✔
87	const visibleIndexes = camera.visiblePanels.reduce((visibles, panel) => {	2✔
88	visibles[panel.index] = true;	2✔
89	return visibles;	5✔
90	}, {});
91		1✔
92	panels.forEach(panel => {	2✔
93	if (panel.index in visibleIndexes \|\| panel.loading) {	7✔
94	panel.markForShow();	2✔
95	} else if (!flicking.holding) {	4✔
96	// During the input sequence,
97	// Do not remove panel elements as it won't trigger touchend event.
98	panel.markForHide();	4✔
99	}
100	});
101
102	camera.updateOffset();	2✔
103	}
104	}	5✔
105
106	export default NormalRenderingStrategy;	5✔

naver / egjs-flicking / 10557177632

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