@studyportals/fawkes 8.7.0 → 8.7.1-0

package/dist/tests/structured-data/ScholarshipStructuredDataFactory.test.mjs

@@ -0,0 +1,292 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import Validator from '@adobe/structured-data-validator';
+import { ScholarshipStructuredDataFactory } from '@/structured-data/ScholarshipStructuredDataFactory';
+describe('ScholarshipStructuredDataFactory', () => {
+    let factory;
+    let mockCurrencyService;
+    let mockScholarshipCards;
+    let validator;
+    beforeEach(async () => {
+        // Fetch the current schema.org schema and create validator instance
+        const schemaOrgJson = await (await fetch('https://schema.org/version/latest/schemaorg-current-https.jsonld')).json();
+        validator = new Validator(schemaOrgJson);
+        // Mock the currency conversion service
+        mockCurrencyService = {
+            convert: vi.fn().mockResolvedValue(5000) // Mock conversion to USD
+        };
+        factory = new ScholarshipStructuredDataFactory(mockCurrencyService);
+        Object.defineProperty(global, 'window', {
+            value: {
+                location: {
+                    host: 'studyportals.com'
+                }
+            }
+        });
+        // Create mock data
+        setupMockData();
+    });
+    function setupMockData() {
+        // Mock scholarship cards
+        mockScholarshipCards = createMockScholarshipCards();
+    }
+    function createMockScholarshipCards() {
+        // Card 1 - Scholarship with monetary value
+        const card1 = {
+            getScholarshipVirtualName: vi.fn().mockReturnValue('/scholarships/tech-excellence-scholarship'),
+            getScholarshipTitle: vi.fn().mockReturnValue('Tech Excellence Scholarship'),
+            getDescriptionOfApplicationBasis: vi.fn().mockReturnValue('Merit-based scholarship for outstanding computer science students'),
+            getProviderName: vi.fn().mockReturnValue('Tech University Foundation'),
+            getDescriptionOfBenefits: vi.fn().mockReturnValue('10000 USD full tuition coverage')
+        };
+        // Card 2 - Scholarship with non-monetary benefits
+        const card2 = {
+            getScholarshipVirtualName: vi.fn().mockReturnValue('/scholarships/research-opportunity-grant'),
+            getScholarshipTitle: vi.fn().mockReturnValue('Research Opportunity Grant'),
+            getDescriptionOfApplicationBasis: vi.fn().mockReturnValue('Research-based opportunity for graduate students'),
+            getProviderName: vi.fn().mockReturnValue('International Research Institute'),
+            getDescriptionOfBenefits: vi.fn().mockReturnValue('Research mentorship and laboratory access')
+        };
+        // Card 3 - Scholarship with monetary value in different currency
+        const card3 = {
+            getScholarshipVirtualName: vi.fn().mockReturnValue('/scholarships/european-excellence-award'),
+            getScholarshipTitle: vi.fn().mockReturnValue('European Excellence Award'),
+            getDescriptionOfApplicationBasis: vi.fn().mockReturnValue('Academic excellence award for European students'),
+            getProviderName: vi.fn().mockReturnValue('European Education Foundation'),
+            getDescriptionOfBenefits: vi.fn().mockReturnValue('8000 EUR partial tuition support')
+        };
+        // Card 4 - Scholarship with missing optional fields
+        const card4 = {
+            getScholarshipVirtualName: vi.fn().mockReturnValue('/scholarships/basic-support-grant'),
+            getScholarshipTitle: vi.fn().mockReturnValue(null),
+            getDescriptionOfApplicationBasis: vi.fn().mockReturnValue(null),
+            getProviderName: vi.fn().mockReturnValue(null),
+            getDescriptionOfBenefits: vi.fn().mockReturnValue(null)
+        };
+        // Card 5 - Scholarship with invalid monetary format
+        const card5 = {
+            getScholarshipVirtualName: vi.fn().mockReturnValue('/scholarships/invalid-format-scholarship'),
+            getScholarshipTitle: vi.fn().mockReturnValue('Invalid Format Scholarship'),
+            getDescriptionOfApplicationBasis: vi.fn().mockReturnValue('Test scholarship with invalid format'),
+            getProviderName: vi.fn().mockReturnValue('Test Foundation'),
+            getDescriptionOfBenefits: vi.fn().mockReturnValue('Invalid amount format')
+        };
+        return [card1, card2, card3, card4, card5];
+    }
+    describe('buildStructuredDataForCard', () => {
+        it('should build MonetaryGrant structured data for scholarship with monetary value', async () => {
+            const entity = {
+                card: mockScholarshipCards[0],
+                offer: undefined,
+                reviewRating: undefined,
+                paywall: undefined
+            };
+            const result = await factory['buildStructuredDataForCard'](entity);
+            expect(result).toBeDefined();
+            expect(result?.['@type']).toBe('MonetaryGrant');
+            expect(result?.name).toBe('Tech Excellence Scholarship');
+            expect(result?.description).toBe('Merit-based scholarship for outstanding computer science students');
+            expect(result?.funder).toBe('Tech University Foundation');
+            expect(result?.url).toBe('https://studyportals.com/scholarships/tech-excellence-scholarship');
+            expect(result?.amount).toBeDefined();
+            expect(result?.amount?.['@type']).toBe('MonetaryAmount');
+            expect(result?.amount?.value).toBe(5000); // Mocked conversion result
+            expect(result?.amount?.currency).toBe('USD');
+        });
+        it('should build MonetaryGrant structured data for scholarship with non-monetary benefits', async () => {
+            const entity = {
+                card: mockScholarshipCards[1],
+                offer: undefined,
+                reviewRating: undefined,
+                paywall: undefined
+            };
+            const result = await factory['buildStructuredDataForCard'](entity);
+            expect(result).toBeDefined();
+            expect(result?.['@type']).toBe('MonetaryGrant');
+            expect(result?.name).toBe('Research Opportunity Grant');
+            expect(result?.description).toBe('Research-based opportunity for graduate students');
+            expect(result?.funder).toBe('International Research Institute');
+            expect(result?.url).toBe('https://studyportals.com/scholarships/research-opportunity-grant');
+            expect(result?.amount).toBeDefined();
+            expect(result?.amount?.['@type']).toBe('MonetaryAmount');
+            expect(result?.amount?.value).toBe('Research mentorship and laboratory access');
+            expect(result?.amount?.currency).toBeUndefined();
+        });
+        it('should handle scholarship with missing optional fields', async () => {
+            const entity = {
+                card: mockScholarshipCards[3],
+                offer: undefined,
+                reviewRating: undefined,
+                paywall: undefined
+            };
+            const result = await factory['buildStructuredDataForCard'](entity);
+            expect(result).toBeDefined();
+            expect(result?.['@type']).toBe('MonetaryGrant');
+            expect(result?.name).toBeUndefined();
+            expect(result?.description).toBeUndefined();
+            expect(result?.funder).toBeUndefined();
+            expect(result?.url).toBe('https://studyportals.com/scholarships/basic-support-grant');
+            expect(result?.amount).toBeDefined();
+            expect(result?.amount?.['@type']).toBe('MonetaryAmount');
+            expect(result?.amount?.value).toBeUndefined();
+        });
+        it('should add paywall data when provided', async () => {
+            const paywallData = {
+                isAccessibleForFree: false,
+                cssSelector: '.Paywalled',
+                accessMode: 'registration'
+            };
+            const entity = {
+                card: mockScholarshipCards[0],
+                offer: undefined,
+                reviewRating: undefined,
+                paywall: paywallData
+            };
+            const result = await factory['buildStructuredDataForCard'](entity);
+            expect(result).toBeDefined();
+            expect(result?.isAccessibleForFree).toBe(false);
+            // Note: cssSelector and accessMode are not added by the base class addPaywallToStructuredData method
+            // Only isAccessibleForFree is added to the structured data
+        });
+    });
+    describe('getOfferData', () => {
+        it('should return offer data for scholarship with monetary value', async () => {
+            const card = mockScholarshipCards[0]; // Has "10000 USD" benefits
+            const result = await factory['getOfferData'](card);
+            expect(result).toBeDefined();
+            expect(result?.price).toBe(5000); // Mocked conversion result
+            expect(result?.category).toBe('tuition');
+            expect(result?.validFrom).toBeUndefined();
+            expect(mockCurrencyService.convert).toHaveBeenCalledWith(10000, 'USD', 'USD');
+        });
+        it('should return offer data for scholarship with different currency', async () => {
+            const card = mockScholarshipCards[2]; // Has "8000 EUR" benefits
+            const result = await factory['getOfferData'](card);
+            expect(result).toBeDefined();
+            expect(result?.price).toBe(5000); // Mocked conversion result
+            expect(result?.category).toBe('tuition');
+            expect(result?.validFrom).toBeUndefined();
+            expect(mockCurrencyService.convert).toHaveBeenCalledWith(8000, 'EUR', 'USD');
+        });
+        it('should return undefined for scholarship with non-monetary benefits', async () => {
+            const card = mockScholarshipCards[1]; // Has non-monetary benefits
+            const result = await factory['getOfferData'](card);
+            expect(result).toBeUndefined();
+        });
+        it('should return undefined for scholarship with no benefits', async () => {
+            const card = mockScholarshipCards[3]; // Has null benefits
+            const result = await factory['getOfferData'](card);
+            expect(result).toBeUndefined();
+        });
+        it('should return undefined for scholarship with invalid monetary format', async () => {
+            const card = mockScholarshipCards[4]; // Has invalid format
+            const result = await factory['getOfferData'](card);
+            expect(result).toBeUndefined();
+        });
+    });
+    describe('getPaywallData', () => {
+        it('should return correct paywall configuration', () => {
+            const result = factory['getPaywallData']();
+            expect(result).toBeDefined();
+            expect(result?.isAccessibleForFree).toBe(false);
+            expect(result?.cssSelector).toBe('.Paywalled');
+            expect(result?.accessMode).toBe('registration');
+        });
+    });
+    describe('buildAmount', () => {
+        it('should build amount with currency conversion for monetary benefits', async () => {
+            const card = mockScholarshipCards[0]; // Has "10000 USD" benefits
+            const result = await factory['buildAmount'](card);
+            expect(result).toBeDefined();
+            expect(result?.['@type']).toBe('MonetaryAmount');
+            expect(result?.value).toBe(5000); // Mocked conversion result
+            expect(result?.currency).toBe('USD');
+            expect(mockCurrencyService.convert).toHaveBeenCalledWith(10000, 'USD', 'USD');
+        });
+        it('should build amount with different currency conversion', async () => {
+            const card = mockScholarshipCards[2]; // Has "8000 EUR" benefits
+            const result = await factory['buildAmount'](card);
+            expect(result).toBeDefined();
+            expect(result?.['@type']).toBe('MonetaryAmount');
+            expect(result?.value).toBe(5000); // Mocked conversion result
+            expect(result?.currency).toBe('USD');
+            expect(mockCurrencyService.convert).toHaveBeenCalledWith(8000, 'EUR', 'USD');
+        });
+        it('should build amount with textual value for non-monetary benefits', async () => {
+            const card = mockScholarshipCards[1]; // Has non-monetary benefits
+            const result = await factory['buildAmount'](card);
+            expect(result).toBeDefined();
+            expect(result?.['@type']).toBe('MonetaryAmount');
+            expect(result?.value).toBe('Research mentorship and laboratory access');
+            expect(result?.currency).toBeUndefined();
+        });
+        it('should handle missing benefits gracefully', async () => {
+            const card = mockScholarshipCards[3]; // Has null benefits
+            const result = await factory['buildAmount'](card);
+            expect(result).toBeDefined();
+            expect(result?.['@type']).toBe('MonetaryAmount');
+            expect(result?.value).toBeUndefined();
+            expect(result?.currency).toBeUndefined();
+        });
+        it('should handle invalid monetary format', async () => {
+            const card = mockScholarshipCards[4]; // Has invalid format
+            const result = await factory['buildAmount'](card);
+            expect(result).toBeDefined();
+            expect(result?.['@type']).toBe('MonetaryAmount');
+            expect(result?.value).toBe('Invalid amount format');
+            expect(result?.currency).toBeUndefined();
+        });
+    });
+    describe('Schema.org validation', () => {
+        it('should generate valid MonetaryGrant schema for scholarship with monetary value', async () => {
+            const entity = {
+                card: mockScholarshipCards[0],
+                offer: undefined,
+                reviewRating: undefined,
+                paywall: undefined
+            };
+            const result = await factory['buildStructuredDataForCard'](entity);
+            expect(result).toBeDefined();
+            // Validate against schema.org using Adobe validator format
+            const validationResults = await validator.validate({ jsonld: { MonetaryGrant: [result] } });
+            expect(validationResults.filter((issue) => issue.severity === 'ERROR')).toHaveLength(0);
+        });
+        it('should generate valid MonetaryGrant schema for scholarship with non-monetary value', async () => {
+            const entity = {
+                card: mockScholarshipCards[1],
+                offer: undefined,
+                reviewRating: undefined,
+                paywall: undefined
+            };
+            const result = await factory['buildStructuredDataForCard'](entity);
+            expect(result).toBeDefined();
+            // Validate against schema.org using Adobe validator format
+            const validationResults = await validator.validate({ jsonld: { MonetaryGrant: [result] } });
+            expect(validationResults.filter((issue) => issue.severity === 'ERROR')).toHaveLength(0);
+        });
+    });
+    describe('Currency conversion edge cases', () => {
+        it('should handle currency conversion errors gracefully', async () => {
+            // Mock currency service to throw an error
+            mockCurrencyService.convert = vi.fn().mockRejectedValue(new Error('Conversion failed'));
+            const factoryWithFailingService = new ScholarshipStructuredDataFactory(mockCurrencyService);
+            const card = mockScholarshipCards[0];
+            // Should not throw, but handle the error gracefully
+            await expect(factoryWithFailingService['buildAmount'](card)).rejects.toThrow('Conversion failed');
+        });
+        it('should round conversion results to whole numbers', async () => {
+            // Mock currency service to return decimal value
+            mockCurrencyService.convert = vi.fn().mockResolvedValue(4999.75);
+            const card = mockScholarshipCards[0];
+            const result = await factory['getOfferData'](card);
+            expect(result?.price).toBe(5000); // Should be rounded
+        });
+    });
+    describe('Integration with base class', () => {
+        it('should properly extend SearchStructuredDataFactory', () => {
+            expect(factory).toBeInstanceOf(ScholarshipStructuredDataFactory);
+            expect(typeof factory['buildStructuredDataForCard']).toBe('function');
+            expect(typeof factory['getOfferData']).toBe('function');
+            expect(typeof factory['getPaywallData']).toBe('function');
+        });
+    });
+});

package/dist/tests/structured-data/SearchStructuredDataFactory.paywall.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/tests/structured-data/SearchStructuredDataFactory.paywall.test.mjs

@@ -0,0 +1,258 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { SearchStructuredDataFactory } from '../../src/structured-data/SearchStructuredDataFactory';
+import { PageTypes } from '../../src/enums/PageTypes';
+class TestStructuredDataFactory extends SearchStructuredDataFactory {
+    paywallConfig;
+    buildStructuredDataForCard(entity) {
+        const structured = {
+            "@type": "Thing",
+            "@id": `https://example.com/${entity.card.id}`,
+            "name": entity.card.name,
+            "url": `https://example.com/${entity.card.id}`
+        };
+        // Add paywall information to the structured data if present
+        this.addPaywallToStructuredData(structured, entity.paywall);
+        return structured;
+    }
+    getPaywallData() {
+        return this.paywallConfig;
+    }
+    // Override the buildStructuredData method to manually create entities with paywall data
+    async buildStructuredData(title, description, cards, faqItems = [], breadcrumbs = [], listItemStructure = false, pageType) {
+        // Create entities with paywall data for cards that have paywall
+        const entities = cards.map(card => ({
+            card,
+            paywall: card.hasPaywall ? {
+                isAccessibleForFree: false,
+                cssSelector: '.paywall-container'
+            } : undefined
+        }));
+        // Call the parent method logic but with our custom entity processing
+        const mainEntities = [];
+        for (const entity of entities) {
+            const structuredData = await this.buildStructuredDataForCard(entity);
+            if (structuredData) {
+                mainEntities.push(structuredData);
+            }
+        }
+        const data = {
+            '@context': 'https://schema.org',
+            '@type': 'SearchResultsPage',
+            'name': title,
+            description,
+            'mainEntity': mainEntities
+        };
+        // Get page-level paywall data
+        const paywallData = this.getPaywallData();
+        // Construct page parts (FAQ + paywall element)
+        const parts = [];
+        if (faqItems.length > 0) {
+            parts.push({
+                '@type': 'FAQPage',
+                'mainEntity': faqItems.map(item => ({
+                    '@type': 'Question',
+                    'name': item.question,
+                    'acceptedAnswer': {
+                        '@type': 'Answer',
+                        'text': item.answer
+                    }
+                }))
+            });
+        }
+        if (paywallData && paywallData.cssSelector) {
+            parts.push({
+                '@type': 'WebPageElement',
+                'isAccessibleForFree': paywallData.isAccessibleForFree,
+                'cssSelector': paywallData.cssSelector
+            });
+        }
+        if (parts.length === 1 && parts[0]['@type'] === 'FAQPage') {
+            data.hasPart = parts[0];
+        }
+        else if (parts.length > 0) {
+            data.hasPart = parts;
+        }
+        if (paywallData) {
+            data.isAccessibleForFree = paywallData.isAccessibleForFree;
+        }
+        return data;
+    }
+    // Test helper method to set page-level paywall
+    setPagePaywall(paywall) {
+        this.paywallConfig = paywall;
+    }
+}
+describe('SearchStructuredDataFactory Paywall Support', () => {
+    let factory;
+    let mockCards;
+    beforeEach(() => {
+        factory = new TestStructuredDataFactory();
+        mockCards = [
+            { id: '1', name: 'Free Content' },
+            { id: '2', name: 'Premium Content', hasPaywall: true },
+            { id: '3', name: 'Another Free Content' }
+        ];
+    });
+    it('should generate structured data without paywall when no paywall data provided', async () => {
+        const result = await factory.buildStructuredData('Test Page', 'A test page', [{ id: '1', name: 'Free Content' }], [], []);
+        expect(result['@context']).toBe('https://schema.org');
+        expect(result['@type']).toBe('SearchResultsPage');
+        expect(result.name).toBe('Test Page');
+        expect(result.description).toBe('A test page');
+        expect(result.mainEntity).toHaveLength(1);
+        expect(result.isAccessibleForFree).toBeUndefined();
+        expect(result.hasPart).toBeUndefined();
+    });
+    it('should add page-level paywall information when paywall data provided', async () => {
+        const pagePaywall = {
+            isAccessibleForFree: false,
+            cssSelector: '.page-paywall'
+        };
+        factory.setPagePaywall(pagePaywall);
+        const result = await factory.buildStructuredData('Premium Content List', 'A list of premium content items', mockCards, [], []);
+        expect(result.isAccessibleForFree).toBe(false);
+        expect(result.hasPart).toBeDefined();
+        expect(Array.isArray(result.hasPart)).toBe(true);
+        const parts = result.hasPart;
+        const paywallElement = parts.find(part => part['@type'] === 'WebPageElement');
+        expect(paywallElement).toBeDefined();
+        expect(paywallElement.isAccessibleForFree).toBe(false);
+        expect(paywallElement.cssSelector).toBe('.page-paywall');
+    });
+    it('should add paywall information to individual cards when they have paywall data', async () => {
+        const result = await factory.buildStructuredData('Mixed Content', 'Free and premium content', mockCards, [], []);
+        expect(result.mainEntity).toHaveLength(3);
+        // Check the premium content item (index 1)
+        const premiumItem = result.mainEntity[1];
+        expect(premiumItem.name).toBe('Premium Content');
+        expect(premiumItem.isAccessibleForFree).toBe(false);
+        // Individual cards should not have a paywall object - only isAccessibleForFree
+        // Check the free content items (index 0 and 2)
+        const freeItem1 = result.mainEntity[0];
+        const freeItem2 = result.mainEntity[2];
+        expect(freeItem1.name).toBe('Free Content');
+        expect(freeItem1.isAccessibleForFree).toBeUndefined();
+        expect(freeItem2.name).toBe('Another Free Content');
+        expect(freeItem2.isAccessibleForFree).toBeUndefined();
+    });
+    it('should handle mixed FAQ and paywall in hasPart', async () => {
+        const faqItems = [
+            { question: 'What is this?', answer: 'This is a test' }
+        ];
+        const pagePaywall = {
+            isAccessibleForFree: false,
+            cssSelector: '.subscription-wall'
+        };
+        factory.setPagePaywall(pagePaywall);
+        const result = await factory.buildStructuredData('FAQ with Paywall', 'Content with both FAQ and paywall', mockCards, faqItems, []);
+        expect(result.hasPart).toBeDefined();
+        expect(Array.isArray(result.hasPart)).toBe(true);
+        const parts = result.hasPart;
+        expect(parts).toHaveLength(2);
+        const faqPage = parts.find(part => part['@type'] === 'FAQPage');
+        const paywallElement = parts.find(part => part['@type'] === 'WebPageElement');
+        expect(faqPage).toBeDefined();
+        expect(paywallElement).toBeDefined();
+        expect(paywallElement.cssSelector).toBe('.subscription-wall');
+    });
+    it('should create paywall WebPageElement only when cssSelector is provided', async () => {
+        const pagePaywall = {
+            isAccessibleForFree: false
+        };
+        factory.setPagePaywall(pagePaywall);
+        const result = await factory.buildStructuredData('Paywall without CSS Selector', 'Should not create WebPageElement', mockCards, [], []);
+        expect(result.isAccessibleForFree).toBe(false);
+        expect(result.hasPart).toBeUndefined(); // No WebPageElement should be created without cssSelector
+    });
+});
+// Simple test factory that uses parent's buildStructuredData method
+class SimpleTestStructuredDataFactory extends SearchStructuredDataFactory {
+    buildStructuredDataForCard(entity) {
+        return {
+            "@type": "Thing",
+            "@id": `https://example.com/${entity.card.id}`,
+            "name": entity.card.name,
+            "url": `https://example.com/${entity.card.id}`
+        };
+    }
+}
+describe('SearchStructuredDataFactory PageType Parameter', () => {
+    let factory;
+    let mockCards;
+    beforeEach(() => {
+        factory = new SimpleTestStructuredDataFactory();
+        mockCards = [
+            { id: '1', name: 'Content Item 1' },
+            { id: '2', name: 'Content Item 2' },
+            { id: '3', name: 'Content Item 3' }
+        ];
+    });
+    it('should use SearchResultsPage as default when pageType is not specified', async () => {
+        const result = await factory.buildStructuredData('Default Page Type Test', 'Testing default page type behavior', mockCards, [], []);
+        expect(result['@type']).toBe('SearchResultsPage');
+        expect(result['@context']).toBe('https://schema.org');
+        expect(result.name).toBe('Default Page Type Test');
+        expect(result.mainEntity).toHaveLength(3);
+    });
+    it('should use WebPage when pageType is explicitly set to WEB_PAGE', async () => {
+        const result = await factory.buildStructuredData('WebPage Type Test', 'Testing with explicit WebPage type', mockCards, [], [], false, PageTypes.WEB_PAGE);
+        expect(result['@type']).toBe('WebPage');
+        expect(result['@context']).toBe('https://schema.org');
+        expect(result.name).toBe('WebPage Type Test');
+        expect(result.mainEntity).toHaveLength(3);
+    });
+    it('should use SearchResultsPage when pageType is explicitly set to SEARCH_RESULTS_PAGE', async () => {
+        const result = await factory.buildStructuredData('SearchResultsPage Type Test', 'Testing with explicit SearchResultsPage type', mockCards, [], [], false, PageTypes.SEARCH_RESULTS_PAGE);
+        expect(result['@type']).toBe('SearchResultsPage');
+        expect(result['@context']).toBe('https://schema.org');
+        expect(result.name).toBe('SearchResultsPage Type Test');
+    });
+    it('should use WebPage when listItemStructure is true and no pageType specified', async () => {
+        const result = await factory.buildStructuredData('List Item Structure Test', 'Testing listItemStructure default behavior', mockCards, [], [], true // listItemStructure = true
+        );
+        expect(result['@type']).toBe('WebPage');
+        // Verify that listItemStructure wrapped items properly
+        expect(result.mainEntity).toHaveLength(1);
+        expect(result.mainEntity[0]['@type']).toBe('ItemList');
+        expect(result.mainEntity[0].numberOfItems).toBe(3);
+    });
+    it('should override listItemStructure default when pageType is explicitly provided', async () => {
+        const result = await factory.buildStructuredData('Override Test', 'Testing pageType override of listItemStructure', mockCards, [], [], true, // listItemStructure = true (would default to WebPage)
+        PageTypes.SEARCH_RESULTS_PAGE // but we explicitly want SearchResultsPage
+        );
+        expect(result['@type']).toBe('SearchResultsPage');
+        // Still should have listItemStructure wrapping
+        expect(result.mainEntity).toHaveLength(1);
+        expect(result.mainEntity[0]['@type']).toBe('ItemList');
+    });
+    it('should maintain all structured data properties when using WebPage type', async () => {
+        const faqItems = [
+            { question: 'What is this?', answer: 'This is a test' }
+        ];
+        const result = await factory.buildStructuredData('WebPage with All Features', 'Testing WebPage type with FAQ', mockCards, faqItems, [], false, PageTypes.WEB_PAGE);
+        expect(result['@type']).toBe('WebPage');
+        expect(result['@context']).toBe('https://schema.org');
+        expect(result.name).toBe('WebPage with All Features');
+        expect(result.description).toBe('Testing WebPage type with FAQ');
+        expect(result.mainEntity).toHaveLength(3);
+        expect(result.hasPart).toBeDefined();
+        expect(result.hasPart['@type']).toBe('FAQPage');
+    });
+    it('should work with empty cards array and custom pageType', async () => {
+        const result = await factory.buildStructuredData('Empty Results', 'No content found', [], [], [], false, PageTypes.WEB_PAGE);
+        expect(result['@type']).toBe('WebPage');
+        expect(result.mainEntity).toHaveLength(0);
+    });
+    it('should combine pageType with listItemStructure and maintain ItemList wrapping', async () => {
+        const result = await factory.buildStructuredData('Combined Test', 'Testing pageType with listItemStructure', mockCards.slice(0, 2), [], [], true, PageTypes.WEB_PAGE);
+        expect(result['@type']).toBe('WebPage');
+        expect(result.mainEntity).toHaveLength(1);
+        const itemList = result.mainEntity[0];
+        expect(itemList['@type']).toBe('ItemList');
+        expect(itemList.numberOfItems).toBe(2);
+        expect(itemList.itemListElement).toHaveLength(2);
+        expect(itemList.itemListElement[0]['@type']).toBe('ListItem');
+        expect(itemList.itemListElement[0].position).toBe(1);
+        expect(itemList.itemListElement[1].position).toBe(2);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@studyportals/fawkes",
-	"version": "8.7.0",
+	"version": "8.7.1-0",
 	"description": "A package to centralize SEO related logic for SBLP and Sitemap Generator.",
 	"files": [
 		"./dist"

package/dist/src/programmes/policies/AttendanceTuitionFee.d.ts

@@ -1,17 +0,0 @@
-import { FilterKey } from '@studyportals/search-filters/server-side';
-import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
-import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
-import { FilterCombinations } from '../../enums/FilterCombinations';
-import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
-import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
-import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
-import { AffordableTuitionFeeRule } from '../rules/AffordableTuitionFeeRule';
-export declare class AttendanceTuitionFee extends ProgrammesBaseIndexabilityPolicy {
-    readonly name: string;
-    readonly description: string;
-    readonly filterKeys: FilterKey[];
-    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule | AffordableTuitionFeeRule)[];
-    constructor(dependencies: IProgrammeSeoDependencies);
-    protected generateUrls(): Promise<string[]>;
-    get filterCombination(): FilterCombinations;
-}

package/dist/src/programmes/policies/AttendanceTuitionFee.js

@@ -1,51 +0,0 @@
-import { FilterKey } from '@studyportals/search-filters/server-side';
-import { TuitionFeeFilterOptionValue } from '@studyportals/search-filters/server-side';
-import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
-import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
-import { FilterCombinations } from '../../enums/FilterCombinations';
-import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
-import { TuitionFeePresenter } from '../../presenters/TuitionFeePresenter';
-import { AttendancePresenter } from '../../presenters/AttendancePresenter';
-import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
-import { AffordableTuitionFeeRule } from '../rules/AffordableTuitionFeeRule';
-export class AttendanceTuitionFee extends ProgrammesBaseIndexabilityPolicy {
-    name = 'Tuition Fee Attendance Policy';
-    description = 'Determines indexing rules for pages filtered by tuition fee and attendance.';
-    filterKeys = [FilterKey.TUITION_FEE, FilterKey.DELIVERY_METHOD];
-    rules = [
-        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
-        new SingleValueSelectedForFilterRule(FilterKey.TUITION_FEE),
-        new OnlyFiltersSelectedRule([FilterKey.DELIVERY_METHOD, FilterKey.TUITION_FEE]),
-        new OnlineAttendanceRule(),
-        new AffordableTuitionFeeRule()
-    ];
-    constructor(dependencies) {
-        super(dependencies);
-        this.initateBaseRules();
-    }
-    async generateUrls() {
-        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
-        const tuitionFeeFragments = TuitionFeePresenter.getInstance().getFragments();
-        const paths = [];
-        const affordableTuition = tuitionFeeFragments.find(t => t.id === TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED);
-        if (!affordableTuition) {
-            return paths;
-        }
-        for (const pageNumber of this.indexablePageNumbers) {
-            for (const attendance of attendanceFragments) {
-                const filterKeyValues = new Map([
-                    [FilterKey.DELIVERY_METHOD, [attendance.id]],
-                    [FilterKey.TUITION_FEE, [affordableTuition.id]]
-                ]);
-                const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
-                if (result) {
-                    paths.push(this.getPathWithPageNumber(`${affordableTuition.path}/${attendance.path}`, pageNumber));
-                }
-            }
-        }
-        return paths;
-    }
-    get filterCombination() {
-        return FilterCombinations.ATTENDANCE_TUITION_FEE;
-    }
-}

package/dist/src/programmes/policies/ContinentTuitionFee.d.ts

@@ -1,16 +0,0 @@
-import { FilterKey } from '@studyportals/search-filters/server-side';
-import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
-import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
-import { FilterCombinations } from '../../enums/FilterCombinations';
-import { AffordableTuitionFeeRule } from '../rules/AffordableTuitionFeeRule';
-import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
-import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
-export declare class ContinentTuitionFee extends ProgrammesBaseIndexabilityPolicy {
-    readonly name: string;
-    readonly description: string;
-    readonly filterKeys: FilterKey[];
-    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | AffordableTuitionFeeRule)[];
-    constructor(dependencies: IProgrammeSeoDependencies);
-    protected generateUrls(): Promise<string[]>;
-    get filterCombination(): FilterCombinations;
-}