fslightbox 3.3.3 → 3.4.0

package/c/elements/setUpClassFacade.js

@@ -0,0 +1,9 @@
+import { removeFromElementClassIfContains } from "../../h/elements/removeFromElementClassIfContains";
+
+export function setUpClassFacade({ core: { classFacade: self }, elements }) {
+    self.removeFromEachElementClassIfContains = (elementsArrayName, className) => {
+        for (let i = 0; i < elements[elementsArrayName].length; i++) {
+            removeFromElementClassIfContains(elements[elementsArrayName][i], className);
+        }
+    }
+}

package/c/events/setUpEventsDispatcher.js

@@ -0,0 +1,7 @@
+export function setUpEventsDispatcher({ core: { eventsDispatcher: self }, props }) {
+    self.dispatch = (eventName) => {
+        if (props[eventName]) {
+            props[eventName]();
+        }
+    };
+}

package/c/events/setUpGlobalEventsController.js

@@ -0,0 +1,39 @@
+import { KeyboardController } from "../keyboard/KeyboardController";
+import { SourcesPointerMove } from "../sources/pointering/move/SourcesPointerMove";
+import { SourcesPointerUp } from "../sources/pointering/up/SourcesPointerUp";
+
+export function setUpGlobalEventsController(
+    {
+        core: { globalEventsController: self, windowResizeActioner, },
+	fs,
+        resolve
+    }
+) {
+    const keyboardController = resolve(KeyboardController);
+    const sourcesPointerMove = resolve(SourcesPointerMove);
+    const sourcesPointerUp = resolve(SourcesPointerUp);
+
+    self.attachListeners = () => {
+        document.addEventListener('pointermove', sourcesPointerMove.listener);
+
+        document.addEventListener('pointerup', sourcesPointerUp.listener);
+
+        addEventListener('resize', windowResizeActioner.runActions);
+
+        document.addEventListener('keydown', keyboardController.listener);
+
+	fs.l();
+    };
+
+    self.removeListeners = () => {
+        document.removeEventListener('pointermove', sourcesPointerMove.listener);
+
+        document.removeEventListener('pointerup', sourcesPointerUp.listener);
+
+        removeEventListener('resize', windowResizeActioner.runActions);
+
+        document.removeEventListener('keydown', keyboardController.listener);
+
+	fs.q();
+    };
+}

package/c/keyboard/KeyboardController.js

@@ -0,0 +1,26 @@
+export function KeyboardController(
+	{
+		core: {
+			lightboxCloser,
+			slideChangeFacade
+		},
+		fs
+	}
+) {
+    this.listener = (e) => {
+        switch (e.key) {
+            case 'Escape':
+                lightboxCloser.closeLightbox();
+                break;
+            case 'ArrowLeft':
+                slideChangeFacade.changeToPrevious();
+                break;
+            case 'ArrowRight':
+                slideChangeFacade.changeToNext();
+                break;
+            case 'F11':
+                e.preventDefault();
+                fs.t();
+        }
+    };
+}

package/c/main-component/closing/LightboxCloseActioner.js

@@ -0,0 +1,46 @@
+import { FADE_OUT_STRONG_CLASS_NAME, OPEN_CLASS_NAME } from "../../../cn/classes-names";
+import { ANIMATION_TIME } from "../../../cn/css-constants";
+
+export function LightboxCloseActioner(
+    {
+        core: {
+            eventsDispatcher,
+            globalEventsController,
+            scrollbarRecompensor
+        },
+        data,
+        elements,
+	fs,
+        props,
+        sourcePointerProps
+    }
+) {
+    this.isLightboxFadingOut = false;
+
+    this.runActions = () => {
+        this.isLightboxFadingOut = true;
+
+        elements.container.classList.add(FADE_OUT_STRONG_CLASS_NAME);
+
+        globalEventsController.removeListeners();
+
+        if (props.exitFullscreenOnClose && data.ifs) {
+            fs.x();
+        }
+
+        setTimeout(() => {
+            this.isLightboxFadingOut = false;
+
+            sourcePointerProps.isPointering = false;
+
+            elements.container.classList.remove(FADE_OUT_STRONG_CLASS_NAME);
+            document.documentElement.classList.remove(OPEN_CLASS_NAME);
+
+            scrollbarRecompensor.removeRecompense();
+
+            document.body.removeChild(elements.container);
+
+            eventsDispatcher.dispatch('onClose');
+        }, ANIMATION_TIME - 30);
+    };
+}

package/c/main-component/closing/setUpLightboxCloser.js

@@ -0,0 +1,11 @@
+import { LightboxCloseActioner } from "./LightboxCloseActioner";
+
+export function setUpLightboxCloser({ core: { lightboxCloser: self }, resolve }) {
+    const lightboxCloseActioner = resolve(LightboxCloseActioner);
+
+    self.closeLightbox = () => {
+        if (!lightboxCloseActioner.isLightboxFadingOut) {
+            lightboxCloseActioner.runActions();
+        }
+    };
+}

package/c/scrollbar/gsw.js

@@ -0,0 +1 @@
+export function gsw(){var e1=document.createElement("div"),s=e1.style,e2=document.createElement("div");s.visibility="hidden";s.width="100px";s.msOverflowStyle="scrollbar";s.overflow="scroll";e2.style.width='100%';document.body.appendChild(e1);var w1=e1.offsetWidth;e1.appendChild(e2);var w2=e2.offsetWidth;return w1-w2;}

package/c/scrollbar/setUpScrollbarRecompensor.js

@@ -0,0 +1,20 @@
+export function setUpScrollbarRecompensor({ data, core: { scrollbarRecompensor: self } }) {
+    self.addRecompense = () => {
+        (document.readyState === "complete") ?
+            ifBodyIsHigherThanWindowAddRecompenseToScrollbar() :
+            addEventListener('load', () => {
+                ifBodyIsHigherThanWindowAddRecompenseToScrollbar();
+                self.addRecompense = ifBodyIsHigherThanWindowAddRecompenseToScrollbar;
+            });
+    };
+
+    function ifBodyIsHigherThanWindowAddRecompenseToScrollbar() {
+        if (document.body.offsetHeight > innerHeight) {
+            document.body.style.marginRight = data.scrollbarWidth + 'px';
+        }
+    }
+
+    self.removeRecompense = () => {
+        document.body.style.removeProperty('margin-right');
+    };
+}

package/c/setUpCore.js

@@ -0,0 +1,30 @@
+import { setUpClassFacade } from "./elements/setUpClassFacade";
+import { setUpEventsDispatcher } from "./events/setUpEventsDispatcher";
+import{sfs}from"./sfs";
+import { setUpGlobalEventsController } from "./events/setUpGlobalEventsController";
+import { setUpLightboxCloser } from "./main-component/closing/setUpLightboxCloser";
+import { setUpScrollbarRecompensor } from "./scrollbar/setUpScrollbarRecompensor";
+import { setUpSlideIndexChanger } from "./slide/setUpSlideIndexChanger";
+import { setUpSlideChangeFacade } from "./slide/setUpSlideChangeFacade";
+import { setUpSourceDisplayFacade } from "./sources/setUpSourceDisplayFacade";
+import { setUpStageManager } from "./stage/setUpStageManager";
+import{ssws}from"./stage/ssws";
+import { setUpSourcesPointerDown } from "./sources/pointering/down/setUpSourcesPointerDown";
+import { setUpWindowResizeActioner } from "./sizes/setUpWindowResizeActioner";
+
+export function setUpCore(fsLightbox) {
+    setUpClassFacade(fsLightbox);
+    setUpEventsDispatcher(fsLightbox);
+    sfs(fsLightbox);
+    setUpGlobalEventsController(fsLightbox);
+    setUpLightboxCloser(fsLightbox);
+    setUpScrollbarRecompensor(fsLightbox);
+    setUpSlideChangeFacade(fsLightbox);
+    setUpSlideIndexChanger(fsLightbox);
+    setUpSourcesPointerDown(fsLightbox);
+    setUpSourceDisplayFacade(fsLightbox);
+    setUpStageManager(fsLightbox);
+    ssws(fsLightbox);
+    setUpWindowResizeActioner(fsLightbox);
+}
+

package/c/sfs.js

@@ -0,0 +1 @@
+export function sfs({componentsServices,data,fs:self}){var FS_CHANGE_EVENTS_NAMES=["fullscreenchange","webkitfullscreenchange","mozfullscreenchange","MSFullscreenChange"];self.o=()=>{componentsServices.ofs();var documentElement=document.documentElement;if(documentElement.requestFullscreen){documentElement.requestFullscreen();}else if(documentElement.mozRequestFullScreen){documentElement.mozRequestFullScreen();}else if(documentElement.webkitRequestFullscreen){documentElement.webkitRequestFullscreen();}else if(documentElement.msRequestFullscreen){documentElement.msRequestFullscreen();}};self.x=()=>{componentsServices.xfs();if(document.exitFullscreen){document.exitFullscreen();}else if(document.mozCancelFullScreen){document.mozCancelFullScreen();}else if(document.webkitExitFullscreen){document.webkitExitFullscreen();}else if(document.msExitFullscreen){document.msExitFullscreen();}};self.t=function(){data.ifs?self.x():self.o()};self.l=function(){m("addEventListener");};self.q=function(){m("removeEventListener")};function m(listen_method_name){for(var i=0;i<FS_CHANGE_EVENTS_NAMES.length;i++){document[listen_method_name](FS_CHANGE_EVENTS_NAMES[i],l)}}function l(){document.fullscreenElement||document.webkitIsFullScreen||document.mozFullScreen||document.msFullscreenElement?componentsServices.ofs():componentsServices.xfs();}}

package/c/sizes/setUpWindowResizeActioner.js

@@ -0,0 +1,38 @@
+import { removeFromElementClassIfContains } from "../../h/elements/removeFromElementClassIfContains";
+import { TRANSFORM_TRANSITION_CLASS_NAME } from "../../cn/classes-names";
+
+export function setUpWindowResizeActioner(
+    {
+        collections: { sourceSizers },
+        core: { windowResizeActioner: self },
+        data,
+        elements: { smw },
+        stageIndexes
+    }
+) {
+    self.runActions = () => {
+        // decreasing max source dimensions for better UX
+        (innerWidth < 992) ?
+            data.maxSourceWidth = innerWidth :
+            data.maxSourceWidth = 0.9 * innerWidth;
+        data.maxSourceHeight = 0.9 * innerHeight;
+
+        for (let i = 0; i < smw.length; i++) {
+            smw[i].d();	
+
+            // if source is Invalid or if lightbox is initialized there are no sourceSizers
+            // so we need to check if it exists
+            if (sourceSizers[i]) {
+                sourceSizers[i].adjustSize();
+            }
+        }
+
+	var pi=stageIndexes.previous,ni=stageIndexes.next;
+	if (pi !== undefined) {
+		smw[pi].ne();
+	}
+	if (ni !== undefined) {
+		smw[ni].p();
+	}
+    };
+}

package/c/slide/setUpSlideChangeFacade.js

@@ -0,0 +1,23 @@
+export function setUpSlideChangeFacade(
+    {
+        core: {
+            slideChangeFacade: self,
+            slideIndexChanger,
+            stageManager
+        },
+        props: { sources }
+    }
+) {
+    if (sources.length > 1) {
+        self.changeToPrevious = () => {
+            slideIndexChanger.jumpTo(stageManager.getPreviousSlideIndex());
+        };
+
+        self.changeToNext = () => {
+            slideIndexChanger.jumpTo(stageManager.getNextSlideIndex());
+        };
+    } else {
+        self.changeToPrevious = () => {};
+        self.changeToNext = () => {};
+    }
+}

package/c/slide/setUpSlideIndexChanger.js

@@ -0,0 +1,89 @@
+import { ANIMATION_TIME } from "../../cn/css-constants";
+import { SOURCE_ANIMATION_WRAPPER } from "../../cn/elements";
+import {
+    FADE_IN_CLASS_NAME, FADE_IN_STRONG_CLASS_NAME,
+    FADE_OUT_CLASS_NAME,
+    TRANSFORM_TRANSITION_CLASS_NAME,
+} from "../../cn/classes-names";
+import { removeFromElementClassIfContains } from "../../h/elements/removeFromElementClassIfContains";
+import { getQueuedAction } from "../timeouts/getQueuedAction";
+
+export function setUpSlideIndexChanger(
+    {
+        componentsServices,
+        core: { slideIndexChanger: self, sourceDisplayFacade, stageManager },
+        elements: { smw, sourceAnimationWrappers },
+	isl,
+        stageIndexes,
+	sws
+    }
+) {
+    self.changeTo = (i) => {
+        stageIndexes.current = i;
+
+        stageManager.updateStageIndexes();
+
+        componentsServices.setSlideNumber(i + 1);
+
+        sourceDisplayFacade.displaySourcesWhichShouldBeDisplayed();
+    };
+
+    self.jumpTo = (i) => {
+        var opi=stageIndexes.previous,oi=stageIndexes.current,oni=stageIndexes.next,ipl=isl[oi],icl=isl[i];
+        self.changeTo(i);
+
+	for (var j = 0; j < smw.length; j++) {
+		smw[j].d();
+	}
+
+	sws.d(oi);
+	sws.c();
+
+	requestAnimationFrame(function(){
+		requestAnimationFrame(function(){
+			var pi=stageIndexes.previous,ni=stageIndexes.next;
+
+			// The checking whether the source is loaded was done before reflow because if source would load after a slide change but before a reflow, inexpected animation may be added—in the case of a current source, a slide change animation would be added instead of initial animation after a load.
+			if (ipl) {
+				sourceAnimationWrappers[oi]
+					.classList.add(FADE_OUT_CLASS_NAME);
+			}
+			if (icl) {
+				sourceAnimationWrappers[stageIndexes.current]
+					.classList.add(FADE_IN_CLASS_NAME);
+			}
+
+			sws.a();
+
+			if (pi !== undefined && pi !== oi) {
+				smw[pi].ne();
+			}
+			smw[stageIndexes.current].n();
+			if (ni !== undefined && ni !== oi) {
+				smw[ni].p();
+			}
+
+			sws.b(opi);
+			sws.b(oni);
+
+			// If source is not loaded, then there are no animations, therefore no postponed transform.
+			if (isl[oi]) {
+				setTimeout(hoss, ANIMATION_TIME - 40);		
+			} else {
+				hoss();
+			}
+
+			function hoss() {
+				if (!stageManager.i(oi)) {
+					smw[oi].h();
+					smw[oi].n();
+				} else if (oi === stageIndexes.previous) {
+					smw[oi].ne();
+				} else if (oi === stageIndexes.next) {
+					smw[oi].p();
+				}
+			}
+		});
+	});
+    };
+}

package/c/so.js

@@ -0,0 +1 @@
+import{PREFIX,OPEN_CLASS_NAME,FULL_DIMENSION_CLASS_NAME,FADE_IN_STRONG_CLASS_NAME}from"../cn/classes-names";import{setUpStageManager}from"./stage/setUpStageManager";import{createSources}from"./sources/creating/createSources";import{renderSourceWrappersContainer}from"../cm/sources/renderSourceWrappersContainer";import{renderNav}from"../cm/nav/renderNav";import{renderSlideButtons}from"../cm/renderSlideButtons";import{renderSlideSwipingHoverer}from"../cm/renderSlideSwipingHoverer";import{setUpCore}from"./setUpCore";import{gsw}from"./scrollbar/gsw";export function so(o){var{componentsServices,core:{eventsDispatcher,globalEventsController,scrollbarRecompensor,sourceDisplayFacade,stageManager,windowResizeActioner},data,elements,props,stageIndexes,sws}=o;o.open=(i=0)=>{var opi=stageIndexes.previous,oci=stageIndexes.current,oni=stageIndexes.next;stageIndexes.current=i;if(!data.i){setUpStageManager(o)}stageManager.updateStageIndexes();if(data.i){sws.c();sws.a();sws.b(opi);sws.b(oci);sws.b(oni);eventsDispatcher.dispatch("onShow")}else{ini()}stageManager.updateStageIndexes();sourceDisplayFacade.displaySourcesWhichShouldBeDisplayed();componentsServices.setSlideNumber(i+1);document.body.appendChild(elements.container);document.documentElement.classList.add(OPEN_CLASS_NAME);scrollbarRecompensor.addRecompense();globalEventsController.attachListeners();windowResizeActioner.runActions();elements.smw[stageIndexes.current].n();eventsDispatcher.dispatch("onOpen")};function ini(){data.i=true;data.scrollbarWidth=gsw(o);setUpCore(o);elements.container=document.createElement("div");elements.container.className=`${PREFIX}container ${FULL_DIMENSION_CLASS_NAME} ${FADE_IN_STRONG_CLASS_NAME}`;renderSlideSwipingHoverer(o);renderNav(o);renderSourceWrappersContainer(o);if(o.props.sources.length>1){renderSlideButtons(o);}createSources(o);eventsDispatcher.dispatch("onInit")}}

package/c/sources/SourceLoadActioner.js

@@ -0,0 +1,32 @@
+import { SourceSizer } from "./SourceSizer";
+import { FADE_IN_STRONG_CLASS_NAME, OPACITY_1_CLASS_NAME } from "../../cn/classes-names";
+
+export function SourceLoadActioner(
+    {
+        collections: { sourceSizers },
+        elements: { sourceAnimationWrappers, sources },
+	isl,
+        resolve
+    }, i
+) {
+    this.runActions = (defaultWidth, defaultHeight) => {
+	isl[i]=true;
+        sources[i].classList.add(OPACITY_1_CLASS_NAME);
+        sourceAnimationWrappers[i].classList.add(FADE_IN_STRONG_CLASS_NAME);
+        sourceAnimationWrappers[i]
+		.removeChild(sourceAnimationWrappers[i].firstChild);
+
+        runNormalLoadActions(defaultWidth, defaultHeight);
+        this.runActions = runNormalLoadActions;
+    };
+
+    /**
+     * Next loads after initial occur only while using 'srcset' so need to recreate SourceSizer.
+     *
+     * Note: Reopening lightbox does not trigger image load.
+     */
+    function runNormalLoadActions(defaultWidth, defaultHeight) {
+        sourceSizers[i] = resolve(SourceSizer, [i, defaultWidth, defaultHeight]);
+        sourceSizers[i].adjustSize();
+    }
+}

package/c/sources/SourceLoadHandler.js

@@ -0,0 +1,41 @@
+import { SourceLoadActioner } from "./SourceLoadActioner";
+
+export function SourceLoadHandler({ elements: { sources }, props, resolve, }, i) {
+    const sourceLoadActioner = resolve(SourceLoadActioner, [i]);
+
+    let wasVideoLoadCalled;
+
+    this.handleImageLoad = ({ target: { naturalWidth, naturalHeight } }) => {
+        sourceLoadActioner.runActions(naturalWidth, naturalHeight);
+    };
+
+    this.handleVideoLoad = ({ target: { videoWidth, videoHeight } }) => {
+        wasVideoLoadCalled = true;
+        sourceLoadActioner.runActions(videoWidth, videoHeight);
+    };
+
+    this.handleNotMetaDatedVideoLoad = () => {
+        if (!wasVideoLoadCalled) {
+            this.handleYoutubeLoad();
+        }
+    };
+
+    this.handleYoutubeLoad = () => {
+        let width = 1920;
+        let height = 1080;
+
+        if (props.maxYoutubeDimensions) {
+            width = props.maxYoutubeDimensions.width;
+            height = props.maxYoutubeDimensions.height;
+        }
+
+        sourceLoadActioner.runActions(width, height);
+    };
+
+    this.handleCustomLoad = () => {
+        setTimeout(() => {
+            const source = sources[i];
+            sourceLoadActioner.runActions(source.offsetWidth, source.offsetHeight);
+        });
+    };
+}

package/c/sources/SourceSizer.js

@@ -0,0 +1,36 @@
+export function SourceSizer({ data, elements: { sources } }, i, defaultWidth, defaultHeight) {
+    const ratio = defaultWidth / defaultHeight;
+    let newHeight = 0;
+
+    /**
+     * This method takes care of setting sources dimensions.
+     * Unfortunately wa cannot only set max width and max height and allow the sources to scale themselves,
+     * due tu Youtube source which dimensions needs to be set in advance.
+     * In this case we are calculating dimensions mathematically.
+     */
+    this.adjustSize = () => {
+        newHeight = data.maxSourceWidth / ratio;
+
+        // wider than higher
+        if (newHeight < data.maxSourceHeight) {
+            if (defaultWidth < data.maxSourceWidth) {
+                newHeight = defaultHeight;
+            }
+            return updateDimensions();
+        }
+
+        // higher than wider
+        if (defaultHeight > data.maxSourceHeight) {
+            newHeight = data.maxSourceHeight;
+        } else {
+            newHeight = defaultHeight;
+        }
+
+        updateDimensions();
+    };
+
+    const updateDimensions = () => {
+        sources[i].style.width = newHeight * ratio + 'px';
+        sources[i].style.height = newHeight + 'px';
+    }
+}

package/c/sources/creating/CreatingSourcesBucket.js

@@ -0,0 +1,29 @@
+import { AutomaticTypeDetector } from "../types/AutomaticTypeDetector";
+
+export function CreatingSourcesBucket(
+    {
+        props: { types, type, sources }, resolve,
+    }, localStorageManager, detectedTypeActioner
+) {
+    this.getTypeSetByClientForIndex = (i) => {
+        let typeSetManuallyByClient;
+
+        if (types && types[i]) {
+            typeSetManuallyByClient = types[i];
+        } else if (type) {
+            typeSetManuallyByClient = type;
+        }
+
+        return typeSetManuallyByClient;
+    };
+
+    this.retrieveTypeWithXhrForIndex = (i) => {
+        // we need to copy index because xhr will for sure come later than next loop iteration
+        const automaticTypeDetector = resolve(AutomaticTypeDetector);
+        automaticTypeDetector.setUrlToCheck(sources[i]);
+        automaticTypeDetector.getSourceType((sourceType) => {
+            localStorageManager.handleReceivedSourceTypeForUrl(sourceType, sources[i]);
+            detectedTypeActioner.runActionsForSourceTypeAndIndex(sourceType, i)
+        });
+    };
+}

package/c/sources/creating/CreatingSourcesLocalStorageManager.js

@@ -0,0 +1,55 @@
+import { SOURCES_TYPES_KEY } from "../../../cn/local-storage-constants";
+import { assignToObject } from "../../../h/objects/assignToObject";
+
+export function CreatingSourcesLocalStorageManager({ props }) {
+    const NEW_TYPE_SHOULD_BE_ADDED_HERE = false;
+    let decodedSourceTypes;
+    let newSourceTypesToDetect = 0;
+    const newTypes = {};
+
+    this.getSourceTypeFromLocalStorageByUrl = (url) => {
+        if (!decodedSourceTypes[url]) {
+            return addNewUrlToDetect(url);
+        }
+        return decodedSourceTypes[url];
+    };
+
+    this.handleReceivedSourceTypeForUrl = (sourceType, url) => {
+        if (newTypes[url] === NEW_TYPE_SHOULD_BE_ADDED_HERE) {
+            newSourceTypesToDetect--;
+
+            // not storing invalid types
+            if (sourceType !== 'invalid') {
+                newTypes[url] = sourceType;
+            } else {
+                delete newTypes[url];
+            }
+
+            if (newSourceTypesToDetect === 0) {
+                assignToObject(decodedSourceTypes, newTypes);
+                try{localStorage.setItem(SOURCES_TYPES_KEY, JSON.stringify(decodedSourceTypes));}catch{}
+            }
+        }
+    };
+
+    const addNewUrlToDetect = (url) => {
+        newSourceTypesToDetect++;
+        newTypes[url] = NEW_TYPE_SHOULD_BE_ADDED_HERE;
+    };
+
+    if (!props.disableLocalStorage) {
+        try{decodedSourceTypes = JSON.parse(localStorage.getItem(SOURCES_TYPES_KEY));}catch{}
+        // we are checking if detected source types contains at certain key source type
+        // when localStorage will be empty we can overwrite this method because we are sure
+        // that at every index will be no source type
+        if (!decodedSourceTypes) {
+            // in ifAllNewTypesAreDetectedStoreAllTypesToLocalStorage we are assigning to
+            // decodedSourceTypes new Types so we need to make it an object to avoid errors
+            decodedSourceTypes = {};
+            this.getSourceTypeFromLocalStorageByUrl = addNewUrlToDetect;
+        }
+    } else {
+        this.getSourceTypeFromLocalStorageByUrl = function () {};
+        this.handleReceivedSourceTypeForUrl = function () {};
+    }
+}

package/c/sources/creating/createSources.js

@@ -0,0 +1,28 @@
+import { CreatingSourcesLocalStorageManager } from "./CreatingSourcesLocalStorageManager";
+import { DetectedTypeActioner } from "../types/DetectedTypeActioner";
+import { CreatingSourcesBucket } from "./CreatingSourcesBucket";
+import { CUSTOM_TYPE } from "../../../cn/core-constants";
+
+export function createSources({ props: { sources }, resolve }) {
+    const localStorageManager = resolve(CreatingSourcesLocalStorageManager);
+    const detectedTypeActioner = resolve(DetectedTypeActioner);
+    const creatingSourcesBucket = resolve(CreatingSourcesBucket, [localStorageManager, detectedTypeActioner]);
+
+    for (let i = 0; i < sources.length; i++) {
+        if (typeof sources[i] !== "string") {
+            detectedTypeActioner.runActionsForSourceTypeAndIndex(CUSTOM_TYPE, i);
+            continue;
+        }
+
+        const typeSetManuallyByClient = creatingSourcesBucket.getTypeSetByClientForIndex(i);
+        if (typeSetManuallyByClient) {
+            detectedTypeActioner.runActionsForSourceTypeAndIndex(typeSetManuallyByClient, i);
+            continue;
+        }
+
+        const sourceTypeRetrievedWithoutXhr = localStorageManager.getSourceTypeFromLocalStorageByUrl(sources[i]);
+        (sourceTypeRetrievedWithoutXhr) ?
+            detectedTypeActioner.runActionsForSourceTypeAndIndex(sourceTypeRetrievedWithoutXhr, i) :
+            creatingSourcesBucket.retrieveTypeWithXhrForIndex(i);
+    }
+}

package/c/sources/pointering/down/setUpSourcesPointerDown.js

@@ -0,0 +1,38 @@
+import { SOURCE_MAIN_WRAPPERS } from "../../../../cn/elements";
+import { TRANSFORM_TRANSITION_CLASS_NAME } from "../../../../cn/classes-names";
+
+export function setUpSourcesPointerDown(
+    {
+        core: { classFacade, sourcesPointerDown: self },
+        elements: { smw, sources },
+        sourcePointerProps,
+        stageIndexes
+    }
+) {
+    self.listener = (e) => {
+        /**
+         * Preventing default to disable image 'copying' behavior on Firefox desktop browser.
+         * Cannot prevent default on video click because video would become unclickable in IE11.
+         */
+        if (e.target.tagName !== 'VIDEO') {
+            e.preventDefault();
+        }
+
+        sourcePointerProps.isPointering = true;
+
+        sourcePointerProps.downScreenX = e.screenX;
+
+        sourcePointerProps.swipedX = 0;
+
+        const currentElement = sources[stageIndexes.current];
+        (currentElement && currentElement.contains(e.target)) ?
+            sourcePointerProps.isSourceDownEventTarget = true :
+            sourcePointerProps.isSourceDownEventTarget = false;
+
+	for (var i=0;i<smw.length;i++) {
+		smw[i].d();
+	}
+    };
+}
+
+

package/c/sources/pointering/move/SourcesPointerMove.js

@@ -0,0 +1,16 @@
+import { SourcesPointerMoveActioner } from "./SourcesPointerMoveActioner";
+
+export function SourcesPointerMove({ props: { sources }, resolve, sourcePointerProps }) {
+    const sourcesPointerMoveActioner = resolve(SourcesPointerMoveActioner);
+
+    (sources.length === 1) ?
+        this.listener = () => {
+            // if there is only one slide we need to simulate swipe to prevent lightbox from closing
+            sourcePointerProps.swipedX = 1;
+        } :
+        this.listener = (e) => {
+            if (sourcePointerProps.isPointering) {
+                sourcesPointerMoveActioner.runActionsForEvent(e);
+            }
+        };
+}