6817467003

Committed 09 Nov 2023 09:10PM UTC coverage: 82.68% (+0.06%) from 82.622%

Build # 6817467003

Build Type

Pull #836

github

Committed by

web-flow

Commit Message

Merge 10c1ac184 into 6927c3e3d

Pull Request Pull Request #836: fix: fix broken layout when direction rtl is applied

Run Details

4527 of 7296 branches covered (0.0%)

Branch coverage included in aggregate %.

50 of 52 new or added lines in 4 files covered. (96.15%)

6 existing lines in 2 files now uncovered.

11384 of 11948 relevant lines covered (95.28%)

249.34 hits per line

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

89.05

/test/unit/camera/Camera.spec.ts

import { ALIGN, DIRECTION, EVENTS } from "~/const/external";
import Camera from "~/camera/Camera";
import { BoundCameraMode, CircularCameraMode, LinearCameraMode } from "~/camera";
import FlickingError from "~/core/FlickingError";
import * as ERROR from "~/const/error";

import { createFlicking } from "../helper/test-util";
import El from "../helper/El";

describe("Camera", () => {
  describe("Properties", () => {
    it("should have element undefined as default", async () => {
      const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { autoInit: false });
      expect(new Camera(flicking).element).to.be.undefined;
    });

    it("should have position 0 as default", async () => {
      const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { autoInit: false });
      expect(new Camera(flicking).position).to.equal(0);
    });

    it("should have 0 as a default size", async () => {
      const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { autoInit: false });
      expect(new Camera(flicking).size).to.equal(0);
    });

    it("should have alignPosition 0 as default", async () => {
      const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { autoInit: false });
      expect(new Camera(flicking).alignPosition).to.equal(0);
    });

    it("should have range from 0 to 0 as default", async () => {
      const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { autoInit: false });
      expect(new Camera(flicking).range.min).to.equal(0);
      expect(new Camera(flicking).range.max).to.equal(0);
    });

    it("should have visiblePanels as an empty array as default", async () => {
      const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { autoInit: false });
      expect(new Camera(flicking).visiblePanels).to.be.empty;
    });

    it(`should have align ${ALIGN.CENTER} as default`, async () => {
      const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { autoInit: false });
      expect(new Camera(flicking).align).to.equal(ALIGN.CENTER);
    });

    it("should return size same to viewport width when horizontal: true", async () => {
      const flicking = await await createFlicking(El.DEFAULT_HORIZONTAL, { horizontal: true });
      const camera = new Camera(flicking);

      camera.init();

      expect(camera.size).not.to.equal(0);
      expect(camera.size).to.equal(flicking.viewport.width);
      expect(camera.size).not.to.equal(flicking.viewport.height);
    });

    it("should return size same to viewport height when horizontal: false", async () => {
      const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { horizontal: false });
      const camera = new Camera(flicking);

      camera.init();

      expect(camera.size).not.to.equal(0);
      expect(camera.size).not.to.equal(flicking.viewport.width);
      expect(camera.size).to.equal(flicking.viewport.height);
    });

    describe("controlParams", () => {
      it("should return current range", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = new Camera(flicking);
        expect(camera.controlParams.range).to.deep.equal(camera.range);
      });

      it("should return current position", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = new Camera(flicking);

        camera.init();
        camera.lookAt(800);

        expect(camera.controlParams.position).to.equal(800);
      });

      it("should always return circular as false", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        expect(new Camera(flicking).controlParams.circular).to.be.false;
      });
    });

    describe("visibleRange", () => {
      it("should return visible range from current position", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = new Camera(flicking, { align: ALIGN.CENTER });

        camera.init();
        camera.updateAlignPos();
        camera.lookAt(500);

        expect(camera.visibleRange.min).to.equal(500 - flicking.viewport.width / 2);
        expect(camera.visibleRange.max).to.equal(500 + flicking.viewport.width / 2);
      });
    });
  });

  describe("Methods", () => {
    describe("init", () => {
      it("should throw a FlickingError with code VAL_MUST_NOT_NULL when there's no camera element inside it", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = new Camera(flicking);

        // Remove viewport's children
        while (flicking.element.firstChild) {
          flicking.element.firstChild.remove();
        }

        expect(() => camera.init())
          .to.throw(FlickingError)
          .with.property("code", ERROR.CODE.VAL_MUST_NOT_NULL);
      });

      it("should set first child of the viewport element as its element", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = new Camera(flicking);

        camera.init();

        expect(camera.element).to.equal(flicking.element.firstChild);
      });

      it("should use LinearCameraMode by default", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = new Camera(flicking);

        camera.init();

        expect(camera.mode).to.be.an.instanceOf(LinearCameraMode);
      });

      it("should use BoundCameraMode when bound is true and the mode is available", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { bound: true });
        const camera = new Camera(flicking);

        camera.init();

        expect(camera.mode).to.be.an.instanceOf(BoundCameraMode);
        expect(camera.mode.checkAvailability()).to.be.true;
      });

      it("should use CircularCameraMode when circular is true and the mode is available", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });
        const camera = new Camera(flicking);

        camera.init();

        expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);
        expect(camera.mode.checkAvailability()).to.be.true;
      });

      it("should use LinearCameraMode when circular is true but it's not available & circularFallback is 'default'", async () => {
        const flicking = await createFlicking(El.viewport().add(El.camera()), { circular: true, circularFallback: "default" });
        const camera = new Camera(flicking);

        camera.init();

        expect(camera.mode).to.be.an.instanceOf(LinearCameraMode);
      });

      it("should use BoundCameraMode when circular is true but it's not available & circularFallback is 'default'", async () => {
        const flicking = await createFlicking(El.viewport().add(El.camera()), { circular: true, circularFallback: "bound" });
        const camera = new Camera(flicking);

        camera.init();

        expect(camera.mode).to.be.an.instanceOf(BoundCameraMode);
      });
    });

    describe("lookAt", () => {
      it("should set position to given value", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = new Camera(flicking);
        const prevPosition = camera.position;

        camera.init();
        camera.lookAt(500);

        expect(camera.position).not.to.equal(prevPosition);
        expect(camera.position).to.equal(500);
      });

      it("should apply transform to camera element", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = new Camera(flicking);

        camera.init();
        camera.lookAt(500);

        expect(camera.element.style.transform).to.equal(`translate(${-(500 - camera.alignPosition)}px)`);
      });

      it("should update visible panels", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = new Camera(flicking);

        camera.init();
        camera.lookAt(500);

        expect(camera.visiblePanels).not.to.be.empty;
      });

      it(`should trigger flicking's ${EVENTS.VISIBLE_CHANGE} on visible panels update`, async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = new Camera(flicking);
        const visibleChangeSpy = sinon.spy();

        flicking.on(EVENTS.VISIBLE_CHANGE, visibleChangeSpy);
        camera.init();
        camera.lookAt(500);

        await (async () => void 0)();

        expect(visibleChangeSpy.calledOnce).to.be.true;
      });

      it(`should trigger flicking's ${EVENTS.NEED_PANEL} for both sides when there're no panels`, async () => {
        const flicking = await createFlicking(El.viewport().add(El.camera()));
        const camera = new Camera(flicking);
        const needPanelSpy = sinon.spy();

        flicking.on(EVENTS.NEED_PANEL, needPanelSpy);
        camera.init();
        camera.lookAt(500);

        expect(needPanelSpy.calledTwice).to.be.true;
        expect(needPanelSpy.calledWithMatch({ direction: DIRECTION.NEXT })).to.be.true;
        expect(needPanelSpy.calledWithMatch({ direction: DIRECTION.PREV })).to.be.true;
      });

      it(`should trigger flicking's ${EVENTS.REACH_EDGE} when moving to range.min`, async () => {
        const flicking = await createFlicking(El.viewport().add(El.camera()));
        const camera = new Camera(flicking);
        const reachEdgeSpy = sinon.spy();

        (camera as any)._range = { min: -1000, max: 1000 };
        camera.init();
        flicking.on(EVENTS.REACH_EDGE, reachEdgeSpy);
        camera.lookAt(-1000);

        expect(reachEdgeSpy.calledOnce).to.be.true;
        expect(reachEdgeSpy.calledWithMatch({ direction: DIRECTION.PREV })).to.be.true;
      });

      it(`should trigger flicking's ${EVENTS.REACH_EDGE} when moving to range.max`, async () => {
        const flicking = await createFlicking(El.viewport().add(El.camera()));
        const camera = new Camera(flicking);
        const reachEdgeSpy = sinon.spy();

        (camera as any)._range = { min: -1000, max: 1000 };
        camera.init();
        flicking.on(EVENTS.REACH_EDGE, reachEdgeSpy);
        camera.lookAt(1000);

        expect(reachEdgeSpy.calledOnce).to.be.true;
        expect(reachEdgeSpy.calledWithMatch({ direction: DIRECTION.NEXT })).to.be.true;
      });

      it(`should noot trigger flicking's ${EVENTS.REACH_EDGE} when moving from outside of range to range.min`, async () => {
        const flicking = await createFlicking(El.viewport().add(El.camera()));
        const camera = new Camera(flicking);
        const reachEdgeSpy = sinon.spy();

        (camera as any)._range = { min: -1000, max: 1000 };
        camera.init();
        camera.lookAt(-1001); // Move to outside
        flicking.on(EVENTS.REACH_EDGE, reachEdgeSpy);
        camera.lookAt(-1000); // Move to outside

        expect(reachEdgeSpy.called).to.be.false;
      });

      it(`should noot trigger flicking's ${EVENTS.REACH_EDGE} when moving from outside of range to range.max`, async () => {
        const flicking = await createFlicking(El.viewport().add(El.camera()));
        const camera = new Camera(flicking);
        const reachEdgeSpy = sinon.spy();

        (camera as any)._range = { min: -1000, max: 1000 };
        camera.init();
        camera.lookAt(1001); // Move to outside
        flicking.on(EVENTS.REACH_EDGE, reachEdgeSpy);
        camera.lookAt(1000); // Move to outside

        expect(reachEdgeSpy.called).to.be.false;
      });
    });

    describe("findAnchorIncludePosition", () => {
      it("should return panel at given position", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = new Camera(flicking);
        const panels = flicking.panels;

        camera.init();
        camera.updateAnchors();

        expect(camera.findAnchorIncludePosition(panels[0].position).panel).to.equal(panels[0]);
        expect(camera.findAnchorIncludePosition(panels[1].position).panel).to.equal(panels[1]);
        expect(camera.findAnchorIncludePosition(panels[2].position).panel).to.equal(panels[2]);
      });

      it("should return null when no panel includes given position", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = new Camera(flicking);
        const panels = flicking.panels;

        camera.init();
        camera.updateAnchors();

        expect(camera.findAnchorIncludePosition(-999999999)).to.be.null;
        expect(camera.findAnchorIncludePosition(999999999)).to.be.null;
        expect(camera.findAnchorIncludePosition(panels[2].range.max + 1)).to.be.null;
        expect(camera.findAnchorIncludePosition(panels[0].range.min - 1)).to.be.null;
      });
    });

    describe("findNearestAnchor", () => {
      it("should return null when there're no panels", async () => {
        const flicking = await createFlicking(El.viewport().add(El.camera()));
        const camera = new Camera(flicking);

        camera.init();
        camera.updateAnchors();

        expect(camera.findNearestAnchor(0)).to.be.null;
      });

      it("should return correct panel underneath it", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = new Camera(flicking);

        camera.init();
        camera.updateAnchors();
        camera.lookAt(flicking.getPanel(1).position);

        const nearestAnchor = camera.findNearestAnchor(camera.position);
        expect(nearestAnchor.panel).to.equal(flicking.getPanel(1));
        expect(nearestAnchor.position).to.equal(flicking.getPanel(1).position);
      });
    });

    describe("updateRange", () => {
      it("should update mode before setting new range", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = flicking.camera;
        const prevMode = camera.mode;

        flicking.circular = true; // This should change mode to Circular
        camera.updateRange();

        const newMode = camera.mode;
        expect(newMode).not.to.equal(prevMode);
        expect(newMode).to.be.instanceOf(CircularCameraMode);
      });
    });

    describe("updateAlignPos", () => {
      it("should update alignPosition using current align value", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = new Camera(flicking, { align: "80%" });
        const prevAlignPosition = camera.alignPosition;

        camera.init();
        camera.updateAlignPos();

        expect(camera.alignPosition).not.to.equal(prevAlignPosition);
        expect(camera.alignPosition).to.equal(flicking.viewport.width * 0.8);
      });

      it("should use property 'camera' if align is given as an object", async () => {
        const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
        const camera = new Camera(flicking, { align: { panel: "30%", camera: "70%" } });
        const prevAlignPosition = camera.alignPosition;

        camera.init();
        camera.updateAlignPos();

        expect(camera.alignPosition).not.to.equal(prevAlignPosition);
        expect(camera.alignPosition).to.equal(flicking.viewport.width * 0.7);
      });
    });
  });
});

1	import { ALIGN, DIRECTION, EVENTS } from "~/const/external";	1✔
2	import Camera from "~/camera/Camera";	1!
3	import { BoundCameraMode, CircularCameraMode, LinearCameraMode } from "~/camera";	×
4	import FlickingError from "~/core/FlickingError";	×
5	import * as ERROR from "~/const/error";
6		×
NEW 7	import { createFlicking } from "../helper/test-util";	×
8	import El from "../helper/El";
9		1!
10	describe("Camera", () => {	×
11	describe("Properties", () => {
12	it("should have element undefined as default", async () => {	×
13	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { autoInit: false });
14	expect(new Camera(flicking).element).to.be.undefined;	1✔
15	});	1!
16		×
17	it("should have position 0 as default", async () => {	×
18	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { autoInit: false });	×
19	expect(new Camera(flicking).position).to.equal(0);	×
20	});
21		1✔
22	it("should have 0 as a default size", async () => {	38✔
23	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { autoInit: false });	37✔
24	expect(new Camera(flicking).size).to.equal(0);	38✔
25	});	×
26		75✔
27	it("should have alignPosition 0 as default", async () => {	37✔
28	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { autoInit: false });
29	expect(new Camera(flicking).alignPosition).to.equal(0);
30	});	1✔
31		38!
32	it("should have range from 0 to 0 as default", async () => {	37✔
33	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { autoInit: false });	111✔
34	expect(new Camera(flicking).range.min).to.equal(0);
35	expect(new Camera(flicking).range.max).to.equal(0);	75!
36	});	150✔
37		150!
38	it("should have visiblePanels as an empty array as default", async () => {	150!
39	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { autoInit: false });	150!
40	expect(new Camera(flicking).visiblePanels).to.be.empty;	75✔
41	});	38✔
42		×
43	it(`should have align ${ALIGN.CENTER} as default`, async () => {	×
44	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { autoInit: false });
45	expect(new Camera(flicking).align).to.equal(ALIGN.CENTER);	37!
46	});	×
47		×
48	it("should return size same to viewport width when horizontal: true", async () => {	×
49	const flicking = await await createFlicking(El.DEFAULT_HORIZONTAL, { horizontal: true });	×
50	const camera = new Camera(flicking);	×
51
52	camera.init();	75✔
53		150✔
54	expect(camera.size).not.to.equal(0);	37!
55	expect(camera.size).to.equal(flicking.viewport.width);
56	expect(camera.size).not.to.equal(flicking.viewport.height);
57	});	1✔
58		3!
59	it("should return size same to viewport height when horizontal: false", async () => {
60	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { horizontal: false });	1✔
61	const camera = new Camera(flicking);	1✔
62		1✔
63	camera.init();	1✔
64		1✔
65	expect(camera.size).not.to.equal(0);	1✔
66	expect(camera.size).not.to.equal(flicking.viewport.width);	1✔
67	expect(camera.size).to.equal(flicking.viewport.height);	1✔
68	});	1✔
69		1✔
70	describe("controlParams", () => {	1✔
71	it("should return current range", async () => {
72	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
73	const camera = new Camera(flicking);	2✔
74	expect(camera.controlParams.range).to.deep.equal(camera.range);	1✔
75	});
76		1✔
77	it("should return current position", async () => {	1✔
78	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
79	const camera = new Camera(flicking);
80
81	camera.init();
82	camera.lookAt(800);	1✔
83
84	expect(camera.controlParams.position).to.equal(800);	1✔
85	});	2✔
86		1✔
87	it("should always return circular as false", async () => {
88	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
89	expect(new Camera(flicking).controlParams.circular).to.be.false;	1✔
90	});	1✔
91	});
92
93	describe("visibleRange", () => {
94	it("should return visible range from current position", async () => {	1✔
95	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
96	const camera = new Camera(flicking, { align: ALIGN.CENTER });	1✔
97		2✔
98	camera.init();	1✔
99	camera.updateAlignPos();
100	camera.lookAt(500);	1✔
101		1✔
102	expect(camera.visibleRange.min).to.equal(500 - flicking.viewport.width / 2);	1✔
103	expect(camera.visibleRange.max).to.equal(500 + flicking.viewport.width / 2);
104	});
105	});
106	});	1✔
107
108	describe("Methods", () => {	1✔
109	describe("init", () => {	2✔
110	it("should throw a FlickingError with code VAL_MUST_NOT_NULL when there's no camera element inside it", async () => {	1✔
111	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
112	const camera = new Camera(flicking);	1✔
113		1✔
114	// Remove viewport's children	1✔
115	while (flicking.element.firstChild) {
116	flicking.element.firstChild.remove();
117	}
118		1✔
119	expect(() => camera.init())
120	.to.throw(FlickingError)	1✔
121	.with.property("code", ERROR.CODE.VAL_MUST_NOT_NULL);	2✔
122	});	1✔
123
124	it("should set first child of the viewport element as its element", async () => {	1✔
125	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
126	const camera = new Camera(flicking);	1✔
127		1✔
128	camera.init();
129
130	expect(camera.element).to.equal(flicking.element.firstChild);
131	});	1✔
132
133	it("should use LinearCameraMode by default", async () => {	1✔
134	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	2✔
135	const camera = new Camera(flicking);	1✔
136
137	camera.init();	1✔
138		1✔
139	expect(camera.mode).to.be.an.instanceOf(LinearCameraMode);	1✔
140	});
141
142	it("should use BoundCameraMode when bound is true and the mode is available", async () => {
143	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { bound: true });	1✔
144	const camera = new Camera(flicking);
145		1✔
146	camera.init();	2✔
147		1✔
148	expect(camera.mode).to.be.an.instanceOf(BoundCameraMode);
149	expect(camera.mode.checkAvailability()).to.be.true;	1✔
150	});	1✔
151		1✔
152	it("should use CircularCameraMode when circular is true and the mode is available", async () => {
153	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL, { circular: true });
154	const camera = new Camera(flicking);
155		1✔
156	camera.init();
157		1✔
158	expect(camera.mode).to.be.an.instanceOf(CircularCameraMode);	3✔
159	expect(camera.mode.checkAvailability()).to.be.true;	1✔
160	});	1✔
161
162	it("should use LinearCameraMode when circular is true but it's not available & circularFallback is 'default'", async () => {	1✔
163	const flicking = await createFlicking(El.viewport().add(El.camera()), { circular: true, circularFallback: "default" });	1✔
164	const camera = new Camera(flicking);	1✔
165		1✔
166	camera.init();	1✔
167		1✔
168	expect(camera.mode).to.be.an.instanceOf(LinearCameraMode);	1✔
169	});
170
171	it("should use BoundCameraMode when circular is true but it's not available & circularFallback is 'default'", async () => {
172	const flicking = await createFlicking(El.viewport().add(El.camera()), { circular: true, circularFallback: "bound" });	1✔
173	const camera = new Camera(flicking);
174		1✔
175	camera.init();	2✔
176		1✔
177	expect(camera.mode).to.be.an.instanceOf(BoundCameraMode);
178	});	1✔
179	});	1✔
180		1✔
181	describe("lookAt", () => {	1✔
182	it("should set position to given value", async () => {	1✔
183	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
184	const camera = new Camera(flicking);	1✔
185	const prevPosition = camera.position;
186
187	camera.init();
188	camera.lookAt(500);	1✔
189		1✔
190	expect(camera.position).not.to.equal(prevPosition);
191	expect(camera.position).to.equal(500);	1✔
192	});	2✔
193		1✔
194	it("should apply transform to camera element", async () => {
195	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
196	const camera = new Camera(flicking);	1✔
197		1✔
198	camera.init();	1✔
199	camera.lookAt(500);
200
201	expect(camera.element.style.transform).to.equal(`translate(${-(500 - camera.alignPosition)}px)`);
202	});	1✔
203
204	it("should update visible panels", async () => {	1✔
205	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	2✔
206	const camera = new Camera(flicking);	1✔
207
208	camera.init();	1✔
209	camera.lookAt(500);	1✔
210		1✔
211	expect(camera.visiblePanels).not.to.be.empty;	1✔
212	});	1✔
213		1✔
214	it(`should trigger flicking's ${EVENTS.VISIBLE_CHANGE} on visible panels update`, async () => {
215	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
216	const camera = new Camera(flicking);
217	const visibleChangeSpy = sinon.spy();	1✔
218
219	flicking.on(EVENTS.VISIBLE_CHANGE, visibleChangeSpy);	1✔
220	camera.init();	2✔
221	camera.lookAt(500);	1✔
222
223	await (async () => void 0)();	1✔
224		1✔
225	expect(visibleChangeSpy.calledOnce).to.be.true;	1✔
226	});
227
228	it(`should trigger flicking's ${EVENTS.NEED_PANEL} for both sides when there're no panels`, async () => {
229	const flicking = await createFlicking(El.viewport().add(El.camera()));
230	const camera = new Camera(flicking);	1✔
231	const needPanelSpy = sinon.spy();	1✔
232
233	flicking.on(EVENTS.NEED_PANEL, needPanelSpy);	1✔
234	camera.init();	2✔
235	camera.lookAt(500);	1✔
236
237	expect(needPanelSpy.calledTwice).to.be.true;	1✔
238	expect(needPanelSpy.calledWithMatch({ direction: DIRECTION.NEXT })).to.be.true;	1✔
239	expect(needPanelSpy.calledWithMatch({ direction: DIRECTION.PREV })).to.be.true;	1✔
240	});	1✔
241		1✔
242	it(`should trigger flicking's ${EVENTS.REACH_EDGE} when moving to range.min`, async () => {	1✔
243	const flicking = await createFlicking(El.viewport().add(El.camera()));	1✔
244	const camera = new Camera(flicking);	1✔
245	const reachEdgeSpy = sinon.spy();
246
247	(camera as any)._range = { min: -1000, max: 1000 };
248	camera.init();
249	flicking.on(EVENTS.REACH_EDGE, reachEdgeSpy);
250	camera.lookAt(-1000);	1✔
251		1✔
252	expect(reachEdgeSpy.calledOnce).to.be.true;	1✔
253	expect(reachEdgeSpy.calledWithMatch({ direction: DIRECTION.PREV })).to.be.true;
254	});	1✔
255		2✔
256	it(`should trigger flicking's ${EVENTS.REACH_EDGE} when moving to range.max`, async () => {	1✔
257	const flicking = await createFlicking(El.viewport().add(El.camera()));
258	const camera = new Camera(flicking);	1✔
259	const reachEdgeSpy = sinon.spy();	1✔
260
261	(camera as any)._range = { min: -1000, max: 1000 };	1✔
262	camera.init();	1✔
263	flicking.on(EVENTS.REACH_EDGE, reachEdgeSpy);
264	camera.lookAt(1000);	1✔
265
266	expect(reachEdgeSpy.calledOnce).to.be.true;
267	expect(reachEdgeSpy.calledWithMatch({ direction: DIRECTION.NEXT })).to.be.true;	1✔
268	});
269
270	it(`should noot trigger flicking's ${EVENTS.REACH_EDGE} when moving from outside of range to range.min`, async () => {
271	const flicking = await createFlicking(El.viewport().add(El.camera()));	1✔
272	const camera = new Camera(flicking);
273	const reachEdgeSpy = sinon.spy();	1✔
274		2✔
275	(camera as any)._range = { min: -1000, max: 1000 };	1✔
276	camera.init();
277	camera.lookAt(-1001); // Move to outside	1✔
278	flicking.on(EVENTS.REACH_EDGE, reachEdgeSpy);	1✔
279	camera.lookAt(-1000); // Move to outside	1✔
280		1✔
281	expect(reachEdgeSpy.called).to.be.false;	1✔
282	});
283
284	it(`should noot trigger flicking's ${EVENTS.REACH_EDGE} when moving from outside of range to range.max`, async () => {
285	const flicking = await createFlicking(El.viewport().add(El.camera()));	1✔
286	const camera = new Camera(flicking);
287	const reachEdgeSpy = sinon.spy();	1✔
288		2✔
289	(camera as any)._range = { min: -1000, max: 1000 };	1✔
290	camera.init();
291	camera.lookAt(1001); // Move to outside	1✔
292	flicking.on(EVENTS.REACH_EDGE, reachEdgeSpy);	1✔
293	camera.lookAt(1000); // Move to outside	1✔
294		1✔
295	expect(reachEdgeSpy.called).to.be.false;	1✔
296	});
297	});
298
299	describe("findAnchorIncludePosition", () => {	1✔
300	it("should return panel at given position", async () => {
301	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
302	const camera = new Camera(flicking);	2✔
303	const panels = flicking.panels;	1✔
304
305	camera.init();	1✔
306	camera.updateAnchors();	1✔
307		1✔
308	expect(camera.findAnchorIncludePosition(panels[0].position).panel).to.equal(panels[0]);	1✔
309	expect(camera.findAnchorIncludePosition(panels[1].position).panel).to.equal(panels[1]);	1✔
310	expect(camera.findAnchorIncludePosition(panels[2].position).panel).to.equal(panels[2]);	1✔
311	});
312
313	it("should return null when no panel includes given position", async () => {
314	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
315	const camera = new Camera(flicking);
316	const panels = flicking.panels;	1✔
317		2✔
318	camera.init();	1✔
319	camera.updateAnchors();
320		1✔
321	expect(camera.findAnchorIncludePosition(-999999999)).to.be.null;	1✔
322	expect(camera.findAnchorIncludePosition(999999999)).to.be.null;	1✔
323	expect(camera.findAnchorIncludePosition(panels[2].range.max + 1)).to.be.null;	1✔
324	expect(camera.findAnchorIncludePosition(panels[0].range.min - 1)).to.be.null;	1✔
325	});	1✔
326	});
327
328	describe("findNearestAnchor", () => {
329	it("should return null when there're no panels", async () => {	1✔
330	const flicking = await createFlicking(El.viewport().add(El.camera()));
331	const camera = new Camera(flicking);	1✔
332		2✔
333	camera.init();	1✔
334	camera.updateAnchors();
335		1✔
336	expect(camera.findNearestAnchor(0)).to.be.null;	1✔
337	});	1✔
338		1✔
339	it("should return correct panel underneath it", async () => {	1✔
340	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
341	const camera = new Camera(flicking);
342
343	camera.init();	1✔
344	camera.updateAnchors();
345	camera.lookAt(flicking.getPanel(1).position);	1✔
346		2✔
347	const nearestAnchor = camera.findNearestAnchor(camera.position);	1✔
348	expect(nearestAnchor.panel).to.equal(flicking.getPanel(1));
349	expect(nearestAnchor.position).to.equal(flicking.getPanel(1).position);	1✔
350	});	1✔
351	});	1✔
352		1✔
353	describe("updateRange", () => {	1✔
354	it("should update mode before setting new range", async () => {
355	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);
356	const camera = flicking.camera;
357	const prevMode = camera.mode;
358		1✔
359	flicking.circular = true; // This should change mode to Circular	1✔
360	camera.updateRange();
361		1✔
362	const newMode = camera.mode;	2✔
363	expect(newMode).not.to.equal(prevMode);	1✔
364	expect(newMode).to.be.instanceOf(CircularCameraMode);
365	});	1✔
366	});	1✔
367		1✔
368	describe("updateAlignPos", () => {	1✔
369	it("should update alignPosition using current align value", async () => {	1✔
370	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
371	const camera = new Camera(flicking, { align: "80%" });	1✔
372	const prevAlignPosition = camera.alignPosition;	1✔
373
374	camera.init();
375	camera.updateAlignPos();
376		1✔
377	expect(camera.alignPosition).not.to.equal(prevAlignPosition);
378	expect(camera.alignPosition).to.equal(flicking.viewport.width * 0.8);	1✔
379	});	2✔
380		1✔
381	it("should use property 'camera' if align is given as an object", async () => {
382	const flicking = await createFlicking(El.DEFAULT_HORIZONTAL);	1✔
383	const camera = new Camera(flicking, { align: { panel: "30%", camera: "70%" } });	1✔
384	const prevAlignPosition = camera.alignPosition;	1✔
385		1✔
386	camera.init();	1✔
387	camera.updateAlignPos();	1✔
388
389	expect(camera.alignPosition).not.to.equal(prevAlignPosition);
390	expect(camera.alignPosition).to.equal(flicking.viewport.width * 0.7);
391	});	1✔
392	});
393	});	1✔
394	});	2✔

naver / egjs-flicking / 6817467003

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