@visitscotland/component-library 5.76.0 → 5.78.0

package/dist/src/components/itineraries/components/__tests__/ItineraryStopInfo.jest.spec.js

@@ -0,0 +1,425 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var test_utils_1 = require("@vue/test-utils");
+var ItineraryStopInfo_vue_1 = __importDefault(require("../ItineraryStopInfo.vue"));
+var openingTimesData_json_1 = __importDefault(require("./data/openingTimesData.json"));
+var openingTimesDataClosed_json_1 = __importDefault(require("./data/openingTimesDataClosed.json"));
+test_utils_1.config.global.renderStubDefaultSlot = true;
+var currentDayData = [{
+        key: 'thursday',
+        day: 'Thursdays',
+        startTime: '09:30',
+        endTime: '18:00',
+        state: 'open',
+        provisional: true
+    }];
+var currentDayDataUsual = [{
+        key: 'thursday',
+        day: 'Thursdays',
+        startTime: '09:30',
+        endTime: '18:00',
+        state: 'open',
+        provisional: false
+    }];
+var dayDataMultiple = [
+    {
+        key: 'thursday',
+        day: 'Thursdays',
+        startTime: '09:30',
+        endTime: '12:00',
+        state: 'open',
+        provisional: false
+    },
+    {
+        key: 'thursday',
+        day: 'Thursdays',
+        startTime: '12:30',
+        endTime: '18:00',
+        state: 'open',
+        provisional: false
+    },
+];
+var dayDataNoTimes = [{
+        key: 'thursday',
+        day: 'Thursdays',
+        startTime: '',
+        endTime: '',
+        provisional: false
+    }];
+var dayDataClosedState = [{
+        key: 'thursday',
+        day: 'Thursdays',
+        startTime: '',
+        endTime: '',
+        state: 'closed',
+        provisional: false
+    }];
+var factoryShallowMount = function () { return (0, test_utils_1.shallowMount)(ItineraryStopInfo_vue_1["default"], {
+    propsData: {
+        openingTime: '09:00',
+        closingTime: '17:00',
+        openingTimesLink: 'http://www.visitscotland.com',
+        openingHours: openingTimesData_json_1["default"].openingHours,
+        closedText: 'Closed',
+        closingSoonText: 'Closing soon',
+        openText: 'Open',
+        usualText: 'Usually',
+        provisionalText: 'Provisionally',
+        temporarilyClosedText: 'Temporarily closed',
+        toText: 'To text',
+        andText: 'And text'
+    },
+    slots: {
+        'stop-link-text': 'All opening times',
+        'stop-charge-text': 'Free admission'
+    }
+}); };
+var wrapper;
+beforeEach(function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                wrapper = factoryShallowMount();
+                return [4 /*yield*/, wrapper.setData({
+                        currentDayData: currentDayData,
+                        ukDate: '25/11/2021',
+                        dayDataIndex: 0,
+                        openingMessage: 'open',
+                        isCurrentTimeframe: false,
+                        parsedHours: openingTimesData_json_1["default"].openingHours
+                    })];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/, wrapper.vm.isActiveDate()];
+            case 2:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+describe('VsItineraryStopInfo', function () {
+    it('should render a component with the data-test attribute `vs-itinerary-stop-info`', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            expect(wrapper.find('[data-test="vs-itinerary-stop-info"]').exists()).toBe(true);
+            return [2 /*return*/];
+        });
+    }); });
+    describe(':props', function () {
+        it('renders content inserted into the slot when the stop is open', function () {
+            expect(wrapper.find('[data-test="vs-itinerary-stop-status"]').text()).toContain('Open');
+        });
+        it('renders content inserted into the slot when the stop is closed', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, wrapper.setData({
+                            openingMessage: 'closed'
+                        })];
+                    case 1:
+                        _a.sent();
+                        expect(wrapper.find('[data-test="vs-itinerary-stop-status"]').text()).toContain('Closed');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('renders content inserted into the slot when the stop is closing soon', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, wrapper.setData({
+                            openingMessage: 'closing soon'
+                        })];
+                    case 1:
+                        _a.sent();
+                        expect(wrapper.find('[data-test="vs-itinerary-stop-status"]').text()).toContain('Closing soon');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('renders the correct provisional text', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, wrapper.setData({
+                            openingMessage: 'closed'
+                        })];
+                    case 1:
+                        _a.sent();
+                        expect(wrapper.find('[data-test="vs-itinerary-stop-hours"]').text()).toContain('Provisionally');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('renders the correct usual text', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, wrapper.setData({
+                            currentDayData: currentDayDataUsual
+                        })];
+                    case 1:
+                        _a.sent();
+                        expect(wrapper.find('[data-test="vs-itinerary-stop-hours"]').text()).toContain('Usually');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('renders the correct text if it is long term closed', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        wrapper.setData({
+                            closedLongTerm: true,
+                            openingMessage: 'closed'
+                        });
+                        return [4 /*yield*/, wrapper.vm.$nextTick()];
+                    case 1:
+                        _a.sent();
+                        expect(wrapper.find('[data-test="vs-itinerary-stop-status"]').text()).toContain('Temporarily closed');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('renders the `to` text prop correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                expect(wrapper.find('[data-test="vs-itinerary-stop-hours"]').text()).toContain('To text');
+                return [2 /*return*/];
+            });
+        }); });
+        it('renders the `and` text prop correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, wrapper.setData({
+                            currentDayData: dayDataMultiple
+                        })];
+                    case 1:
+                        _a.sent();
+                        expect(wrapper.find('[data-test="vs-itinerary-stop-hours"]').text()).toContain('And text');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('only shows the opening hours link if a prop is supplied', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, wrapper.setProps({
+                            openingTimesLink: null
+                        })];
+                    case 1:
+                        _a.sent();
+                        expect(wrapper.find('[data-test="vs-stop-link"]').exists()).toBe(false);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe(':computed', function () {
+        it('only does not render an opening status messages if hoursMessage is not defined', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var currentTime;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, wrapper.setData({
+                            currentDayData: dayDataNoTimes,
+                            openingMessage: ''
+                        })];
+                    case 1:
+                        _a.sent();
+                        currentTime = {
+                            day: 4,
+                            hours: 12,
+                            minutes: 30
+                        };
+                        return [4 /*yield*/, wrapper.vm.compareTimes(currentTime, dayDataNoTimes, 0)];
+                    case 2:
+                        _a.sent();
+                        expect(wrapper.find('[data-test="vs-itinerary-stop-status"]').exists()).toBe(false);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe(':slots', function () {
+        it('renders content inserted into the vs-stop-link-text slot', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, wrapper.setData({
+                            openingMessage: 'closing soon'
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, wrapper.vm.$nextTick()];
+                    case 2:
+                        _a.sent();
+                        expect(wrapper.find('[data-test="vs-stop-link"]').html()).toContain('All opening times');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('renders content inserted into the vs-stop-charge-text slot', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                expect(wrapper.find('[data-test="vs-stop-charge-text"]').text()).toBe('Free admission');
+                return [2 /*return*/];
+            });
+        }); });
+    });
+    describe(':methods', function () {
+        it('correctly defines whether or not todays date is within the active date parameters', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                expect(wrapper.vm.isCurrentTimeframe).toBe(true);
+                return [2 /*return*/];
+            });
+        }); });
+        it('sets the openingMessage data to `closed` if the current time is outside of the opening hours', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, wrapper.setData({
+                            currentTime: {
+                                day: 4,
+                                hours: 18,
+                                minutes: 30
+                            }
+                        })];
+                    case 1:
+                        _a.sent();
+                        wrapper.vm.getCurrentHoursInfo();
+                        expect(wrapper.vm.openingMessage).toBe('closed');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('sets the openingMessage data to `open` if the current time is inside the opening hours', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, wrapper.setData({
+                            currentTime: {
+                                day: 4,
+                                hours: 12,
+                                minutes: 30
+                            }
+                        })];
+                    case 1:
+                        _a.sent();
+                        wrapper.vm.getCurrentHoursInfo();
+                        expect(wrapper.vm.openingMessage).toBe('open');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('sets the openingMessage data to `closing` if the current time is within 30 mins of the closing time', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, wrapper.setData({
+                            currentTime: {
+                                day: 4,
+                                hours: 17,
+                                minutes: 40
+                            }
+                        })];
+                    case 1:
+                        _a.sent();
+                        wrapper.vm.getCurrentHoursInfo();
+                        expect(wrapper.vm.openingMessage).toBe('closing soon');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('shows closed message if the state is set to `closed`', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var currentTime;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        currentTime = {
+                            day: 4,
+                            hours: 12,
+                            minutes: 0
+                        };
+                        return [4 /*yield*/, wrapper.vm.compareTimes(currentTime, dayDataClosedState, 0)];
+                    case 1:
+                        _a.sent();
+                        expect(wrapper.find('[data-test="vs-itinerary-stop-status"]').html()).toContain('Closed');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('sets the openingMessage data to blank if no times are in the data', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var currentTime;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, wrapper.setData({
+                            openingMessage: ''
+                        })];
+                    case 1:
+                        _a.sent();
+                        currentTime = {
+                            day: 4,
+                            hours: 17,
+                            minutes: 40
+                        };
+                        wrapper.vm.compareTimes(currentTime, dayDataNoTimes, 0);
+                        expect(wrapper.vm.openingMessage).toBe('');
+                        expect(wrapper.find('[data="vs-itinerary-stop-status"]').exists()).toBe(false);
+                        expect(wrapper.find('[data="vs-itinerary-stop-hours"]').exists()).toBe(false);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('sets currentTimeframe to false if current date falls outside of the dates in the opening hours data', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, wrapper.setProps({
+                            openingHours: openingTimesDataClosed_json_1["default"].openingHours
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, wrapper.setData({
+                                parsedHours: openingTimesDataClosed_json_1["default"].openingHours
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, wrapper.vm.isActiveDate()];
+                    case 3:
+                        _a.sent();
+                        expect(wrapper.vm.isCurrentTimeframe).toBe(false);
+                        expect(wrapper.find('[data="vs-itinerary-stop-status"]').exists()).toBe(false);
+                        expect(wrapper.find('[data="vs-itinerary-stop-hours"]').exists()).toBe(false);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});

package/dist/src/components/itineraries/itineraries.store.js

@@ -0,0 +1,22 @@
+"use strict";
+exports.__esModule = true;
+var vue_1 = require("vue");
+var pinia_1 = require("pinia");
+var useItinerariesStore = (0, pinia_1.defineStore)('itineraries', function () {
+    var highlightedStop = (0, vue_1.ref)(null);
+    function setStopHighlighted(newStop) {
+        highlightedStop.value = newStop;
+    }
+    function getHighlightedStopCoordinates() {
+        if (highlightedStop.value) {
+            return highlightedStop.value.geometry.coordinates;
+        }
+        return [-4.07083, 56.18882];
+    }
+    return {
+        highlightedStop: highlightedStop,
+        setStopHighlighted: setStopHighlighted,
+        getHighlightedStopCoordinates: getHighlightedStopCoordinates
+    };
+});
+exports["default"] = useItinerariesStore;

package/dist/src/components/link/__tests__/Link.jest.spec.js

@@ -0,0 +1,178 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var test_utils_1 = require("@vue/test-utils");
+var axe_helper_1 = __importDefault(require("@/../test/unit/helpers/axe-helper"));
+var Link_vue_1 = __importDefault(require("../Link.vue"));
+var Icon_vue_1 = __importDefault(require("../../icon/Icon.vue"));
+var slotContent = 'Link text';
+var factoryShallowMount = function (propsData) { return (0, test_utils_1.shallowMount)(Link_vue_1["default"], {
+    propsData: propsData,
+    slots: {
+        "default": slotContent
+    }
+}); };
+describe('VsLink', function () {
+    it('should render an anchor with class vs-link', function () {
+        var wrapper = factoryShallowMount();
+        expect(wrapper.classes()).toContain('vs-link');
+        expect(wrapper.element.tagName).toBe('A');
+    });
+    describe(':slots', function () {
+        it(':default - should render the slot content', function () {
+            var wrapper = factoryShallowMount();
+            expect(wrapper.text()).toBe(slotContent);
+        });
+    });
+    describe(':props', function () {
+        it(':variant - should render the primary variant by default', function () {
+            var wrapper = factoryShallowMount();
+            expect(wrapper.classes()).toContain('vs-link--variant-primary');
+            expect(wrapper.vm.iconVariant).toBe('cta');
+        });
+        it(':variant - should render the secondary variant', function () {
+            var wrapper = factoryShallowMount({
+                variant: 'secondary'
+            });
+            expect(wrapper.classes()).toContain('vs-link--variant-secondary');
+            expect(wrapper.vm.iconVariant).toBe('primary');
+            expect(wrapper.classes()).not.toContain('vs-link--variant-primary');
+        });
+        it(':variant - should render the on-dark variant', function () {
+            var wrapper = factoryShallowMount({
+                variant: 'on-dark'
+            });
+            expect(wrapper.classes()).toContain('vs-link--variant-on-dark');
+            expect(wrapper.vm.iconVariant).toBe('inverse');
+            expect(wrapper.classes()).not.toContain('vs-link--variant-primary');
+        });
+        it(':href - should apply the supplied href', function () {
+            var href = 'http://google.com';
+            var wrapper = factoryShallowMount({
+                href: href
+            });
+            expect(wrapper.attributes('href')).toBe(href);
+        });
+        it(':type - should not render an special link by default', function () {
+            var wrapper = factoryShallowMount();
+            expect(wrapper.classes()).not.toEqual(expect.arrayContaining([/vs-link--/]));
+            expect(wrapper.attributes('target')).toBe('_self');
+            expect(wrapper.findComponent(Icon_vue_1["default"]).exists()).toBe(false);
+        });
+        it(':type - should render an appropriate link', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var wrapper;
+            return __generator(this, function (_a) {
+                wrapper = factoryShallowMount({
+                    type: 'external'
+                });
+                expect(wrapper.attributes('target')).toBe('_self');
+                expect(wrapper.findComponent(Icon_vue_1["default"]).exists()).toBe(true);
+                return [2 /*return*/];
+            });
+        }); });
+        it(':type - should add a download attribute if download type is used', function () {
+            var wrapper = factoryShallowMount({
+                type: 'download'
+            });
+            expect(wrapper.attributes('download')).toBe('true');
+        });
+        it(':type - should not add a download attribute of false if download type is not used', function () {
+            var wrapper = factoryShallowMount({
+                type: 'internal'
+            });
+            expect(wrapper.attributes()).not.toContain('download');
+        });
+        it('does not render icon for default type', function () {
+            var wrapper = factoryShallowMount();
+            expect(wrapper.findComponent(Icon_vue_1["default"]).exists()).toBe(false);
+        });
+        it('renders correct icon for external type', function () {
+            var wrapper = factoryShallowMount({
+                type: 'external'
+            });
+            var icon = wrapper.findComponent(Icon_vue_1["default"]);
+            expect(icon.exists()).toBe(true);
+            expect(icon.props('icon')).toBe('fa-regular fa-square-arrow-up-right');
+        });
+        it('renders correct icon for internal type', function () {
+            var wrapper = factoryShallowMount({
+                type: 'internal'
+            });
+            var icon = wrapper.findComponent(Icon_vue_1["default"]);
+            expect(icon.exists()).toBe(true);
+            expect(icon.props('icon')).toBe('fa-regular fa-arrow-right');
+        });
+        it('renders correct icon for download type', function () {
+            var wrapper = factoryShallowMount({
+                type: 'download'
+            });
+            var icon = wrapper.findComponent(Icon_vue_1["default"]);
+            expect(icon.exists()).toBe(true);
+            expect(icon.props('icon')).toBe('vs-icon-control-download');
+        });
+        it(':noVisitedStyles - defaults to false', function () {
+            var wrapper = factoryShallowMount();
+            expect(wrapper.classes()).not.toContain('vs-link--no-visited-styles');
+        });
+        it(':noVisitedStyles - applies class when true', function () {
+            var wrapper = factoryShallowMount({
+                noVisitedStyles: true
+            });
+            expect(wrapper.classes()).toContain('vs-link--no-visited-styles');
+        });
+    });
+    describe(':accessibility', function () {
+        it('should not have aXe accessibility issues', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var wrapper, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        wrapper = factoryShallowMount();
+                        _a = expect;
+                        return [4 /*yield*/, (0, axe_helper_1["default"])(wrapper.html())];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]).toHaveNoViolations();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});