@gxpl/sdk 0.0.12 → 0.0.14

package/lib/sdk/transitions/transitionMachine.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transitionMachine = void 0;
+const xstate_1 = require("xstate");
+const getScenesOnInit_1 = require("./utils/getScenesOnInit");
+const getAvailableTransitions_1 = require("./utils/getAvailableTransitions");
+const findRelation_1 = require("./utils/findRelation");
+const isTransitionSuccess_1 = require("./utils/isTransitionSuccess");
+const getScenesOnStart_1 = require("./utils/getScenesOnStart");
+const getScenesOnProgressUpdate_1 = require("./utils/getScenesOnProgressUpdate");
+const getScenesOnEnd_1 = require("./utils/getScenesOnEnd");
+const getScenesOnInstantTransition_1 = require("./utils/getScenesOnInstantTransition");
+const isActiveSwipeTransition_1 = require("./utils/isActiveSwipeTransition");
+const getDeltaAndProgress_1 = require("./utils/getDeltaAndProgress");
+const SWIPE_SUCCESS_THRESHOLD = 130;
+exports.transitionMachine = (0, xstate_1.setup)({
+    types: {
+        input: {},
+        context: {},
+        events: {},
+    },
+    actors: {
+        waitForNextFrame: (0, xstate_1.fromPromise)(() => {
+            return new Promise((resolve) => {
+                requestAnimationFrame(() => {
+                    resolve();
+                });
+            });
+        }),
+    },
+}).createMachine({
+    /** @xstate-layout N4IgpgJg5mDOIC5QBcBOBDAdrAlsnA9pgHToDG+AbmAMQDKA6gJIAKAogPosBKbLAgrwDaABgC6iUAAcCufEUkgAHogBMqgOzEAHAEZdAVm0BmPSIMBOCxoBsAGhABPRABZdx4iI2qLLi9o1jHw0RYwBfMIc0LDlCEnIqWgAVbn4AOTomJKYAeTSOFKYAcSK2blEJJBAZWIUqlQRVGwMdA10rYw19AxttbQdnRpEbYg1-awsRdWMejQMIqIxsPDjiKVQwKXRUHEwoemZ2DjokwSSKxRqVutAGm31PDSftCxnQgyCB13dHnz8AoLWUILEDRZbyEjrTbbXb7RisTgAYXSiLYABkLlUrhDFA0ZhZiKp3ETOkEXF57E5EEFdMQgi9jC5tEYmT0QWDaiQOddMLCDgiuNwckVeHQ6BwAKosAAi-CSbEx0lkPNxiA0LhcxBcIXxIn0IRsGi+CBpdNUL2abimnQs7KWnOI3IhfPhRzYaWliuqypx9UQ-i0vhCUx6TMZRqpCDcHi8PnaNIMGuadpiPOIu1gyCwyA4TrifIgRDA6cwlAIAGti3miCXM9nc-aebCELsy2R0BCKl7sXFVQhbC1VC5TCILLo+pox8bVCJtISrKELG1jCINaoU+DVrAwMhkAAbF1sJJJNGcd2e8SXH29v0IaxaYzGQ0WVSddpdXTG4mjUcuV+BDU-3mEFMAICA4EUatMCvTk+26HR2nUSZVysSlBhcQdfxnbQ-10JkiQ3B0EhwagYJVW9dBsDw9BfHwRBQiw0LUHxRjmRMbHuHoDDGGxCLTKEth2PYyN9W5XENYhdD1Npmnce5R2NYcRhQtp1Q4ywTHCSJQUbCFHV0-NhKxa8bmURBtD1OlhmMfR6OMVDjEUp9PD8VSXHU-wtMWVM9IzLNMBzKDYREm8xIQAxZ1GGxWQXVQPg46dhkJNjGKXEkZ3XbSoOIbddwPIylVgiipJaQwIsfSx7N0Wxp1fYhosNYYXgMf9tF4iIwiAA */
+    id: 'transition',
+    initial: 'active',
+    context: ({ input }) => {
+        const { scenes, startScene, relations } = input;
+        const transitionScenes = (0, getScenesOnInit_1.getScenesOnInit)(startScene, scenes);
+        const availableTransitions = (0, getAvailableTransitions_1.getAvailableTransitions)(startScene, relations);
+        return {
+            input,
+            transitionReady: availableTransitions,
+            transition: null,
+            scenes: transitionScenes
+        };
+    },
+    states: {
+        active: {
+            on: {
+                SWIPE_PREPARE: {
+                    target: 'preparing',
+                    actions: (0, xstate_1.assign)({
+                        transition: ({ event }) => {
+                            return {
+                                stage: 'preparing',
+                                startX: event.touchData.startX,
+                                startY: event.touchData.startY,
+                            };
+                        }
+                    })
+                },
+                TRANSITION_TRIGGER: {
+                    target: 'instant_transitioning',
+                    actions: (0, xstate_1.assign)({
+                        transition: ({ context, event }) => {
+                            const { scenes } = context;
+                            const { to, transition } = event;
+                            const activeScene = scenes[0];
+                            if (!activeScene) {
+                                throw new Error('Active scene not found');
+                            }
+                            const from = activeScene.id;
+                            return Object.assign(Object.assign({ stage: 'active', from,
+                                to }, (transition === 'slide' ? { direction: event.direction } : {})), { type: transition });
+                        },
+                        scenes: ({ context, event }) => {
+                            const { scenes } = context;
+                            const activeScene = scenes[0];
+                            if (!activeScene) {
+                                throw new Error('Active scene not found');
+                            }
+                            const { to, transition } = event;
+                            const newScenes = transition === 'slide'
+                                ? (0, getScenesOnStart_1.getScenesOnSlideStart)({ from: activeScene.id, to }, { x: 0, y: 0 }, event.direction)
+                                : (0, getScenesOnStart_1.getScenesOnFadeStart)({ from: activeScene.id, to }, 0);
+                            return newScenes;
+                        }
+                    })
+                }
+            },
+        },
+        preparing: {
+            on: {
+                SWIPE_START: {
+                    target: 'transitioning',
+                    actions: (0, xstate_1.assign)({
+                        transition: ({ context, event }) => {
+                            const { direction } = event;
+                            const { input, transition, scenes } = context;
+                            const activeScene = scenes[0];
+                            if (!activeScene)
+                                return null;
+                            const relation = (0, findRelation_1.findRelation)(input.relations, activeScene.id, direction);
+                            if (!transition || !('startX' in transition) || !('startY' in transition))
+                                return null;
+                            return {
+                                stage: 'active',
+                                type: relation.type,
+                                from: relation.from,
+                                to: relation.to,
+                                direction,
+                                startX: transition === null || transition === void 0 ? void 0 : transition.startX,
+                                startY: transition === null || transition === void 0 ? void 0 : transition.startY,
+                                currentX: event.touchData.x,
+                                currentY: event.touchData.y,
+                            };
+                        },
+                        scenes: ({ context, event }) => {
+                            const { direction } = event;
+                            const { input, transition, scenes } = context;
+                            const activeScene = scenes[0];
+                            if (!activeScene)
+                                return context.scenes;
+                            const relation = (0, findRelation_1.findRelation)(input.relations, activeScene.id, direction);
+                            if (!transition || !('startX' in transition) || !('startY' in transition))
+                                return context.scenes;
+                            const start = { x: transition.startX, y: transition.startY };
+                            const { deltaX, deltaY, progress } = (0, getDeltaAndProgress_1.getDeltaAndProgress)(event.touchData, start, direction);
+                            const newScenes = relation.type === 'slide'
+                                ? (0, getScenesOnStart_1.getScenesOnSlideStart)(relation, { x: deltaX, y: deltaY }, direction)
+                                : (0, getScenesOnStart_1.getScenesOnFadeStart)(relation, progress);
+                            return newScenes;
+                        }
+                    })
+                },
+                SWIPE_CANCEL: {
+                    target: 'active',
+                    actions: (0, xstate_1.assign)({
+                        transition: null
+                    })
+                }
+            }
+        },
+        transitioning: {
+            on: {
+                SWIPE_PROGRESS_UPDATE: {
+                    actions: (0, xstate_1.assign)({
+                        transition: ({ context, event }) => {
+                            const { transition } = context;
+                            if (!transition || transition.stage !== 'active')
+                                return null;
+                            return Object.assign(Object.assign({}, transition), { stage: 'active', currentX: event.touchData.x, currentY: event.touchData.y });
+                        },
+                        scenes: ({ context, event }) => {
+                            const { transition, scenes } = context;
+                            if (!(0, isActiveSwipeTransition_1.isActiveSwipeTransition)(transition))
+                                return scenes;
+                            const start = { x: transition.startX, y: transition.startY };
+                            const { deltaX, deltaY, progress } = (0, getDeltaAndProgress_1.getDeltaAndProgress)(event.touchData, start, transition.direction);
+                            const newScenes = transition.type === 'slide'
+                                ? (0, getScenesOnProgressUpdate_1.getScenesOnSlideProgressUpdate)(scenes, { x: deltaX, y: deltaY })
+                                : (0, getScenesOnProgressUpdate_1.getScenesOnFadeProgressUpdate)(scenes, transition.to, progress);
+                            return newScenes;
+                        }
+                    })
+                },
+                SWIPE_END: {
+                    target: 'settling',
+                    actions: (0, xstate_1.assign)({
+                        transition: ({ context }) => {
+                            const { transition } = context;
+                            if (!(0, isActiveSwipeTransition_1.isActiveSwipeTransition)(transition))
+                                return null;
+                            const transitionSuccess = (0, isTransitionSuccess_1.isTransitionSuccess)(transition, SWIPE_SUCCESS_THRESHOLD);
+                            return {
+                                stage: 'settling',
+                                success: transitionSuccess,
+                                type: transition.type,
+                                from: transition.from,
+                                to: transition.to,
+                            };
+                        },
+                        scenes: ({ context }) => {
+                            const { transition, scenes } = context;
+                            if (!(0, isActiveSwipeTransition_1.isActiveSwipeTransition)(transition))
+                                return scenes;
+                            const { type } = transition;
+                            const transitionSuccess = (0, isTransitionSuccess_1.isTransitionSuccess)(transition, SWIPE_SUCCESS_THRESHOLD);
+                            const newScenes = type === 'slide'
+                                ? (0, getScenesOnEnd_1.getScenesOnSlideEnd)(scenes, transition, transitionSuccess)
+                                : (0, getScenesOnEnd_1.getScenesOnFadeEnd)(scenes);
+                            return newScenes;
+                        },
+                    })
+                }
+            }
+        },
+        instant_transitioning: {
+            invoke: {
+                src: 'waitForNextFrame',
+                onDone: {
+                    target: 'settling',
+                    actions: (0, xstate_1.assign)({
+                        scenes: ({ context }) => {
+                            const { transition, scenes } = context;
+                            if (!transition || transition.stage !== 'active' || !('type' in transition)) {
+                                return scenes;
+                            }
+                            return (0, getScenesOnInstantTransition_1.getScenesOnInstantTransition)(scenes, transition);
+                        },
+                        transition: ({ context }) => {
+                            const { transition } = context;
+                            if (!transition || transition.stage !== 'active' || !('type' in transition)) {
+                                return null;
+                            }
+                            return {
+                                stage: 'settling',
+                                success: true,
+                                type: transition.type,
+                                from: transition.from,
+                                to: transition.to,
+                            };
+                        }
+                    })
+                }
+            }
+        },
+        settling: {
+            on: {
+                SETTLE_END: {
+                    target: 'active',
+                    actions: (0, xstate_1.assign)({
+                        transition: null,
+                        scenes: ({ context }) => {
+                            const { transition, scenes } = context;
+                            if (!transition || transition.stage !== 'settling')
+                                return scenes;
+                            const activeScene = scenes.find((s) => {
+                                const next = transition.success ? transition.to : transition.from;
+                                return s.id === next;
+                            });
+                            if (!activeScene)
+                                return scenes;
+                            return [activeScene];
+                        },
+                        transitionReady: ({ context }) => {
+                            const { transition, input: { relations } } = context;
+                            if (!transition || transition.stage !== 'settling')
+                                return context.transitionReady;
+                            const next = transition.success ? transition.to : transition.from;
+                            const availableTransitions = (0, getAvailableTransitions_1.getAvailableTransitions)(next, relations);
+                            return availableTransitions;
+                        }
+                    })
+                }
+            }
+        }
+    },
+});

package/lib/sdk/transitions/utils/findRelation.d.ts

@@ -0,0 +1,2 @@
+import type { Direction, Relation } from './types';
+export declare function findRelation(relations: Relation[], from: string, direction: Direction): Relation;

package/lib/sdk/transitions/utils/findRelation.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRelation = findRelation;
+function findRelation(relations, from, direction) {
+    const relation = relations.find((r) => r.from === from && r.direction === direction);
+    if (!relation) {
+        throw new Error(`Relation not found for direction: "${direction}".`);
+    }
+    return relation;
+}

package/lib/sdk/transitions/utils/getAvailableTransitions.d.ts

@@ -0,0 +1,7 @@
+import type { Relation } from './types';
+export declare function getAvailableTransitions(scene: string, relations: Relation[]): {
+    north: boolean;
+    east: boolean;
+    south: boolean;
+    west: boolean;
+};

package/lib/sdk/transitions/utils/getAvailableTransitions.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableTransitions = getAvailableTransitions;
+function getAvailableTransitions(scene, relations) {
+    const availableTransitions = {
+        north: relations.some((r) => r.from === scene && r.direction === 'north'),
+        east: relations.some((r) => r.from === scene && r.direction === 'east'),
+        south: relations.some((r) => r.from === scene && r.direction === 'south'),
+        west: relations.some((r) => r.from === scene && r.direction === 'west')
+    };
+    return availableTransitions;
+}

package/lib/sdk/transitions/utils/getAxis.d.ts

@@ -0,0 +1,2 @@
+import type { Direction } from './types';
+export declare function getAxis(direction: Direction): "horizontal" | "vertical";

package/lib/sdk/transitions/utils/getAxis.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAxis = getAxis;
+function getAxis(direction) {
+    return direction === 'east' || direction === 'west' ? 'horizontal' : 'vertical';
+}

package/lib/sdk/transitions/utils/getDeltaAndProgress.d.ts

@@ -0,0 +1,11 @@
+import type { Direction } from './types';
+export declare function getDeltaAndProgress(current: Delta, start: Delta, direction: Direction): {
+    deltaX: number;
+    deltaY: number;
+    progress: number;
+};
+type Delta = {
+    x: number;
+    y: number;
+};
+export {};

package/lib/sdk/transitions/utils/getDeltaAndProgress.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeltaAndProgress = getDeltaAndProgress;
+const getAxis_1 = require("./getAxis");
+function getDeltaAndProgress(current, start, direction) {
+    const axis = (0, getAxis_1.getAxis)(direction);
+    const deltaX = axis === 'horizontal' ? current.x - start.x : 0;
+    const deltaY = axis === 'vertical' ? current.y - start.y : 0;
+    const progress = axis === 'horizontal'
+        ? Math.abs(deltaX) / window.innerWidth
+        : Math.abs(deltaY) / window.innerHeight;
+    return { deltaX, deltaY, progress };
+}

package/lib/sdk/transitions/utils/getScenesOnEnd.d.ts

@@ -0,0 +1,21 @@
+import type { ActiveTransition, TransitionScene } from './types';
+export declare function getScenesOnSlideEnd(scenes: TransitionScene[], transition: ActiveTransition, success: boolean): {
+    styles: {
+        x: number;
+        y: number;
+        startX: number;
+        startY: number;
+        opacity: number;
+    };
+    id: string;
+}[];
+export declare function getScenesOnFadeEnd(scenes: TransitionScene[]): {
+    styles: {
+        opacity: number;
+        startX: number;
+        startY: number;
+        x: number;
+        y: number;
+    };
+    id: string;
+}[];

package/lib/sdk/transitions/utils/getScenesOnEnd.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScenesOnSlideEnd = getScenesOnSlideEnd;
+exports.getScenesOnFadeEnd = getScenesOnFadeEnd;
+function getScenesOnSlideEnd(scenes, transition, success) {
+    const { from, to, direction } = transition;
+    return scenes.map((s) => {
+        const isNextActiveScene = success ? s.id === to : s.id === from;
+        let prevElX = 0;
+        if (direction === 'east') {
+            prevElX = success ? -window.innerWidth : window.innerWidth;
+        }
+        else if (direction === 'west') {
+            prevElX = success ? window.innerWidth : -window.innerWidth;
+        }
+        let prevElY = 0;
+        if (direction === 'north') {
+            prevElY = success ? window.innerHeight : -window.innerHeight;
+        }
+        else if (direction === 'south') {
+            prevElY = success ? -window.innerHeight : window.innerHeight;
+        }
+        return Object.assign(Object.assign({}, s), { styles: Object.assign(Object.assign({}, s.styles), { x: isNextActiveScene ? 0 : prevElX, y: isNextActiveScene ? 0 : prevElY }) });
+    });
+}
+function getScenesOnFadeEnd(scenes) {
+    return scenes.map((s) => {
+        return Object.assign(Object.assign({}, s), { styles: Object.assign(Object.assign({}, s.styles), { opacity: 1 }) });
+    });
+}

package/lib/sdk/transitions/utils/getScenesOnInit.d.ts

@@ -0,0 +1,6 @@
+import type { TransitionScene } from './types';
+export declare function getScenesOnInit(startScene: string, scenes: Scene[]): TransitionScene[];
+type Scene = {
+    id: string;
+};
+export {};

package/lib/sdk/transitions/utils/getScenesOnInit.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScenesOnInit = getScenesOnInit;
+function getScenesOnInit(startScene, scenes) {
+    const initialScene = scenes.find((scene) => scene.id === startScene);
+    if (!initialScene) {
+        throw new Error(`Initial scene not found: ${startScene}`);
+    }
+    const transitionScene = {
+        id: initialScene.id,
+        styles: {
+            startX: 0,
+            startY: 0,
+            x: 0,
+            y: 0,
+            opacity: 1
+        }
+    };
+    return [transitionScene];
+}

package/lib/sdk/transitions/utils/getScenesOnInstantTransition.d.ts

@@ -0,0 +1,2 @@
+import type { InstantTransition, TransitionScene } from './types';
+export declare function getScenesOnInstantTransition(scenes: TransitionScene[], transition: InstantTransition): TransitionScene[];

package/lib/sdk/transitions/utils/getScenesOnInstantTransition.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScenesOnInstantTransition = getScenesOnInstantTransition;
+function getScenesOnInstantTransition(scenes, transition) {
+    const { type, to, direction } = transition;
+    if (type === 'slide' && direction) {
+        return getScenesOnInstantSlideTransition(scenes, to, direction);
+    }
+    else if (type === 'fade') {
+        return getScenesOnInstantFadeTransition(scenes);
+    }
+    return scenes;
+}
+function getScenesOnInstantSlideTransition(scenes, to, direction) {
+    let fromFinalX = 0;
+    let fromFinalY = 0;
+    if (direction === 'east') {
+        fromFinalX = -window.innerWidth;
+    }
+    else if (direction === 'west') {
+        fromFinalX = window.innerWidth;
+    }
+    else if (direction === 'north') {
+        fromFinalY = window.innerHeight;
+    }
+    else if (direction === 'south') {
+        fromFinalY = -window.innerHeight;
+    }
+    return scenes.map((scene) => {
+        const isToScene = scene.id === to;
+        return Object.assign(Object.assign({}, scene), { styles: Object.assign(Object.assign({}, scene.styles), { x: isToScene ? 0 : fromFinalX, y: isToScene ? 0 : fromFinalY }) });
+    });
+}
+function getScenesOnInstantFadeTransition(scenes) {
+    return scenes.map((scene) => {
+        return Object.assign(Object.assign({}, scene), { styles: Object.assign(Object.assign({}, scene.styles), { opacity: 1 }) });
+    });
+}

package/lib/sdk/transitions/utils/getScenesOnProgressUpdate.d.ts

@@ -0,0 +1,26 @@
+import type { TransitionScene } from './types';
+export declare function getScenesOnSlideProgressUpdate(scenes: TransitionScene[], delta: Delta): {
+    styles: {
+        x: number;
+        y: number;
+        startX: number;
+        startY: number;
+        opacity: number;
+    };
+    id: string;
+}[];
+export declare function getScenesOnFadeProgressUpdate(scenes: TransitionScene[], to: string, progress: number): {
+    styles: {
+        opacity: number;
+        startX: number;
+        startY: number;
+        x: number;
+        y: number;
+    };
+    id: string;
+}[];
+type Delta = {
+    x: number;
+    y: number;
+};
+export {};

package/lib/sdk/transitions/utils/getScenesOnProgressUpdate.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScenesOnSlideProgressUpdate = getScenesOnSlideProgressUpdate;
+exports.getScenesOnFadeProgressUpdate = getScenesOnFadeProgressUpdate;
+const normalizeOpacity_1 = require("./normalizeOpacity");
+function getScenesOnSlideProgressUpdate(scenes, delta) {
+    return scenes.map((scene) => (Object.assign(Object.assign({}, scene), { styles: Object.assign(Object.assign({}, scene.styles), { x: scene.styles.startX + delta.x, y: scene.styles.startY + delta.y }) })));
+}
+function getScenesOnFadeProgressUpdate(scenes, to, progress) {
+    return scenes.map((scene) => {
+        const isNextScene = scene.id === to;
+        const value = isNextScene ? progress : 1;
+        return Object.assign(Object.assign({}, scene), { styles: Object.assign(Object.assign({}, scene.styles), { opacity: (0, normalizeOpacity_1.normalizeOpacity)(value) }) });
+    });
+}

package/lib/sdk/transitions/utils/getScenesOnStart.d.ts

@@ -0,0 +1,21 @@
+import type { Direction, TransitionScene } from './types';
+export declare function getScenesOnFadeStart({ from, to }: FromTo, progress: number): {
+    id: string;
+    styles: {
+        opacity: number;
+        startX: number;
+        startY: number;
+        x: number;
+        y: number;
+    };
+}[];
+export declare function getScenesOnSlideStart({ from, to }: FromTo, delta: Delta, direction: Direction): TransitionScene[];
+type Delta = {
+    x: number;
+    y: number;
+};
+type FromTo = {
+    from: string;
+    to: string;
+};
+export {};

package/lib/sdk/transitions/utils/getScenesOnStart.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScenesOnFadeStart = getScenesOnFadeStart;
+exports.getScenesOnSlideStart = getScenesOnSlideStart;
+const getAxis_1 = require("./getAxis");
+const normalizeOpacity_1 = require("./normalizeOpacity");
+function getScenesOnFadeStart({ from, to }, progress) {
+    const common = {
+        startX: 0,
+        startY: 0,
+        x: 0,
+        y: 0
+    };
+    const sceneFrom = {
+        id: from,
+        styles: Object.assign(Object.assign({}, common), { opacity: 1 })
+    };
+    const sceneTo = {
+        id: to,
+        styles: Object.assign(Object.assign({}, common), { opacity: (0, normalizeOpacity_1.normalizeOpacity)(progress) })
+    };
+    return [sceneFrom, sceneTo];
+}
+function getScenesOnSlideStart({ from, to }, delta, direction) {
+    const common = {
+        opacity: 1,
+    };
+    const sceneFrom = {
+        id: from,
+        styles: Object.assign(Object.assign({}, common), { startX: 0, startY: 0, x: delta.x, y: delta.y })
+    };
+    const startX = getNextSceneSlideStartX(direction);
+    const startY = getNextSceneSlideStartY(direction);
+    const sceneTo = {
+        id: to,
+        styles: Object.assign(Object.assign({}, common), { startX,
+            startY, x: startX + delta.x, y: startY + delta.y })
+    };
+    return [sceneFrom, sceneTo];
+}
+function getNextSceneSlideStartX(direction) {
+    const axis = (0, getAxis_1.getAxis)(direction);
+    if (axis !== 'horizontal')
+        return 0;
+    return direction === 'east' ? window.innerWidth : -window.innerWidth;
+}
+function getNextSceneSlideStartY(direction) {
+    const axis = (0, getAxis_1.getAxis)(direction);
+    if (axis !== 'vertical')
+        return 0;
+    return direction === 'north' ? -window.innerHeight : window.innerHeight;
+}

package/lib/sdk/transitions/utils/isActiveSwipeTransition.d.ts

@@ -0,0 +1,2 @@
+import type { ActiveTransition, Transition } from './types';
+export declare function isActiveSwipeTransition(transition: Transition | null): transition is ActiveTransition;

package/lib/sdk/transitions/utils/isActiveSwipeTransition.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isActiveSwipeTransition = isActiveSwipeTransition;
+function isActiveSwipeTransition(transition) {
+    return transition !== null
+        && transition.stage === 'active'
+        && 'startX' in transition
+        && 'startY' in transition
+        && 'currentX' in transition
+        && 'currentY' in transition
+        && 'direction' in transition;
+}

package/lib/sdk/transitions/utils/isOverThreshold.d.ts

@@ -0,0 +1 @@
+export declare function isOverThreshold(delta: number, threshold: number): boolean;

package/lib/sdk/transitions/utils/isOverThreshold.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOverThreshold = isOverThreshold;
+function isOverThreshold(delta, threshold) {
+    return Math.abs(delta) > threshold;
+}

package/lib/sdk/transitions/utils/isTransitionSuccess.d.ts

@@ -0,0 +1,2 @@
+import type { ActiveTransition } from './types';
+export declare function isTransitionSuccess(transition: ActiveTransition, threshold: number): boolean;

package/lib/sdk/transitions/utils/isTransitionSuccess.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTransitionSuccess = isTransitionSuccess;
+const getAxis_1 = require("./getAxis");
+const isOverThreshold_1 = require("./isOverThreshold");
+function isTransitionSuccess(transition, threshold) {
+    const { currentX, startX, currentY, startY, direction } = transition;
+    const deltaX = currentX - startX;
+    const deltaY = currentY - startY;
+    const axis = (0, getAxis_1.getAxis)(direction);
+    const transitionSuccess = axis === 'horizontal'
+        ? (0, isOverThreshold_1.isOverThreshold)(deltaX, threshold)
+        : (0, isOverThreshold_1.isOverThreshold)(deltaY, threshold);
+    return transitionSuccess;
+}

package/lib/sdk/transitions/utils/normalizeOpacity.d.ts

@@ -0,0 +1 @@
+export declare function normalizeOpacity(value: number): number;

package/lib/sdk/transitions/utils/normalizeOpacity.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOpacity = normalizeOpacity;
+// normalize opacity to ensure that the value is within CSS acceptable range
+// and tune the range slightly to make sure transitionEnd gets fired
+function normalizeOpacity(value) {
+    return Math.max(0.01, Math.min(0.99, value));
+}