@studyportals/fawkes 8.2.2 → 8.2.4-0

package/dist/src/organisations/policies/our-picks/City.js

@@ -0,0 +1,35 @@
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SortingOptions } from '../../../enums/SortingOptions';
+import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
+import { CityPresenter } from '../../../presenters/CityPresenter';
+import { OnlyFullLocationFiltersSelectedRule } from '../../../organisations/rules/OnlyFullLocationFiltersSelectedRule';
+export class City extends OrganisationsSeoIndexabilityPolicy {
+    name = 'City Policy';
+    description = 'Controls indexing of pages filtered by geographic cities, ensuring only SEO-valuable regional content with sufficient search volume is indexed.';
+    sortingOption = SortingOptions.OUR_PICKS;
+    baseRules = [
+        new OnlyFullLocationFiltersSelectedRule()
+    ];
+    async generateUrls() {
+        const cityFragments = await CityPresenter
+            .getInstance(this.dependencies.searchApiClient)
+            .getFragments();
+        const paths = [];
+        for (const city of cityFragments) {
+            const filterKeyValues = new Map([
+                [FilterKey.CITY, [city.id]],
+                [FilterKey.AREA, [city.areaId]],
+                [FilterKey.COUNTRY, [city.countryId]]
+            ]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(city.path));
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.CITY;
+    }
+}

package/dist/src/organisations/rules/OnlyFullLocationFiltersSelectedRule.d.ts

@@ -0,0 +1,10 @@
+import { IRule } from '../../common/IRule';
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+export declare class OnlyFullLocationFiltersSelectedRule implements IRule {
+    private readonly COUNTRIES_WITH_AREAS;
+    getName(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(): Promise<boolean>;
+    getDescription(): string;
+    private isEligible;
+}

package/dist/src/organisations/rules/OnlyFullLocationFiltersSelectedRule.js

@@ -0,0 +1,32 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+export class OnlyFullLocationFiltersSelectedRule {
+    COUNTRIES_WITH_AREAS = ["30", "82", "202"]; //UK, US, AU
+    getName() {
+        return `OnlyFullLocationFiltersSelectedRule`;
+    }
+    async forSearch(dependencies) {
+        return await this.isEligible(dependencies);
+    }
+    forSitemapGenerator() {
+        //TODO
+        return Promise.resolve(false);
+    }
+    getDescription() {
+        return `Only city, country and area (if US, UK or AU) filters are selected`;
+    }
+    async isEligible(dependencies) {
+        const seoInfoBase = dependencies.seoInfoBase;
+        const filterState = dependencies.filterState;
+        const singleCitySelected = await seoInfoBase.singleSelectionFor(FilterKey.CITY, filterState);
+        const singleAreaSelected = await seoInfoBase.singleSelectionFor(FilterKey.AREA, filterState);
+        const singleCountrySelected = await seoInfoBase.singleSelectionFor(FilterKey.COUNTRY, filterState);
+        const needArea = filterState.getSelectedValuesFor(FilterKey.COUNTRY)
+            .some((countryId) => this.COUNTRIES_WITH_AREAS.includes(countryId));
+        if (needArea) {
+            const cityAreaAndCountryOnly = await seoInfoBase.selectionOnlyFor([FilterKey.CITY, FilterKey.COUNTRY, FilterKey.AREA], filterState);
+            return singleCitySelected && singleCountrySelected && singleAreaSelected && cityAreaAndCountryOnly;
+        }
+        const cityAndCountryOnly = await seoInfoBase.selectionOnlyFor([FilterKey.CITY, FilterKey.COUNTRY], filterState);
+        return singleCitySelected && singleCountrySelected && cityAndCountryOnly;
+    }
+}

package/dist/src/presenters/AreaPresenter.d.ts

@@ -9,4 +9,5 @@ export declare class AreaPresenter implements IPresenter {
     static getInstance(): AreaPresenter;
     private generatePaths;
     getFragments(): IAreaFragment[];
+    isPartOfGivenCountries(areaId: string, countries: string[]): boolean;
 }

package/dist/src/presenters/AreaPresenter.js

@@ -32,4 +32,7 @@ export class AreaPresenter {
     getFragments() {
         return this.fragments;
     }
+    isPartOfGivenCountries(areaId, countries) {
+        return areasAll.some(a => a.id === areaId && countries.includes(a.countryId));
+    }
 }

package/dist/src/presenters/CityPresenter.d.ts

@@ -0,0 +1,14 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { ICityFragment } from './fragments/ICityFragment';
+import { IPresenter, ISearchApiClient } from '../../sitemap-generator-seo';
+export declare class CityPresenter implements IPresenter {
+    readonly filterKey: FilterKey;
+    private searchApiClient;
+    private static instance;
+    private resultSize;
+    private constructor();
+    private fragmentsPromise;
+    static getInstance(searchApiClient: ISearchApiClient): CityPresenter;
+    getFragments(): Promise<ICityFragment[]>;
+    private fetchCities;
+}

package/dist/src/presenters/CityPresenter.js

@@ -0,0 +1,60 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { countriesExtendedAll } from '@studyportals/static-domain-data/countries/countries-extended';
+import { countryGetIsoCodePath } from '@studyportals/static-domain-data/countries/country-get-iso-path';
+import { areaGetPath } from '@studyportals/static-domain-data/areas/area-get-path';
+export class CityPresenter {
+    filterKey = FilterKey.CITY;
+    searchApiClient;
+    static instance;
+    resultSize = 600;
+    constructor(searchApiClient) {
+        this.searchApiClient = searchApiClient;
+    }
+    fragmentsPromise = null;
+    static getInstance(searchApiClient) {
+        if (!CityPresenter.instance) {
+            CityPresenter.instance = new CityPresenter(searchApiClient);
+        }
+        return CityPresenter.instance;
+    }
+    async getFragments() {
+        if (!this.fragmentsPromise) {
+            this.fragmentsPromise = this.fetchCities();
+        }
+        return this.fragmentsPromise;
+    }
+    async fetchCities() {
+        try {
+            const data = await this.searchApiClient.getCities();
+            const cityFragments = data.map(city => {
+                const country = countriesExtendedAll.find(item => item.iso?.toLowerCase() === city.countryIsoCode?.toLowerCase());
+                let cityPath = ``;
+                const countryPath = countryGetIsoCodePath(country?.iso || '');
+                if (city.areaId === null || city.areaId === undefined) {
+                    cityPath += countryPath;
+                }
+                if (!city.areaId || city.areaId !== null) {
+                    const area = areaGetPath(city.areaId?.toString() || '');
+                    if (area && area !== '') {
+                        cityPath += `/${area}`;
+                    }
+                    else {
+                        cityPath += countryPath;
+                    }
+                }
+                cityPath += `/${city.virtualPath}`;
+                return {
+                    id: city.id.toString(),
+                    path: cityPath,
+                    areaId: city.areaId?.toString(),
+                    countryId: country ? country.id.toString() : '',
+                };
+            });
+            return cityFragments;
+        }
+        catch (error) {
+            console.error('Error fetching city data:', error);
+            throw error;
+        }
+    }
+}

package/dist/src/presenters/fragments/ICityFragment.d.ts

@@ -0,0 +1,5 @@
+import { IFragment } from './IFragment';
+export interface ICityFragment extends IFragment {
+    areaId: string;
+    countryId: string;
+}

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

@@ -10,7 +10,7 @@ import { AttendancePresenter } from '../../presenters/AttendancePresenter';
 import { DegreePresenter } from '../../presenters/DegreePresenter';
 export class CountryAttendanceDegree extends ProgrammesBaseIndexabilityPolicy {
     name = 'Country Attendance Degree Policy';
-    description = `Determines indexing rules for pages filtered by country,
+    description = `Determines indexing rules for pages filtered by country,
 		study format (online, on-campus, etc.), and degree type.`;
     filterKeys = [FilterKey.COUNTRY, FilterKey.DELIVERY_METHOD, FilterKey.DEGREE_TYPE];
     rules = [

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

@@ -10,7 +10,7 @@ import { DegreePresenter } from '../../presenters/DegreePresenter';
 import { DurationPresenter } from '../../presenters/DurationPresenter';
 export class CountryDurationDegree extends ProgrammesBaseIndexabilityPolicy {
     name = 'Country Duration Degree Policy';
-    description = `Determines indexing rules for pages filtered by country,
+    description = `Determines indexing rules for pages filtered by country,
 		duration (1 year, 2 years, etc.), and degree type.`;
     filterKeys = [FilterKey.COUNTRY, FilterKey.DURATION, FilterKey.DEGREE_TYPE];
     rules = [

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

@@ -8,7 +8,7 @@ import { CountryPresenter } from '../../presenters/CountryPresenter';
 import { EducationalFormPresenter } from '../../presenters/EducationalFormPresenter';
 export class CountryEducationalForm extends ProgrammesBaseIndexabilityPolicy {
     name = 'Country Educational Form Policy';
-    description = `Determines indexing rules for pages filtered by both country,
+    description = `Determines indexing rules for pages filtered by both country,
 		and educational form (academic, semester, summer school, etc.).`;
     filterKeys = [FilterKey.COUNTRY, FilterKey.EDUCATIONAL_FORM];
     rules = [

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

@@ -1,4 +1,4 @@
-import { FilterKey } from '@studyportals/search-filters';
+import { FilterKey } from "../../enums/FilterKey";
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';

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

@@ -1,4 +1,4 @@
-import { FilterKey } from '@studyportals/search-filters';
+import { FilterKey } from "../../enums/FilterKey";
 import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
 import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
 import { FilterCombinations } from '../../enums/FilterCombinations';

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

@@ -9,7 +9,7 @@ import { CountryPresenter } from '../../presenters/CountryPresenter';
 import { EducationalFormPresenter } from '../../presenters/EducationalFormPresenter';
 export class DisciplineCountryEducationalForm extends ProgrammesBaseIndexabilityPolicy {
     name = 'Discipline Country Educational Form Policy';
-    description = `Determines indexing rules for pages filtered by discipline,
+    description = `Determines indexing rules for pages filtered by discipline,
 		country, and educational form (academic, semester, summer school, etc.).`;
     filterKeys = [FilterKey.DISCIPLINES, FilterKey.COUNTRY, FilterKey.EDUCATIONAL_FORM];
     rules = [

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

@@ -8,7 +8,7 @@ import { DisciplinePresenter } from '../../presenters/DisciplinePresenter';
 import { EducationalFormPresenter } from '../../presenters/EducationalFormPresenter';
 export class DisciplineEducationalForm extends ProgrammesBaseIndexabilityPolicy {
     name = 'Discipline Educational Form Policy';
-    description = `Determines indexing rules for pages filtered by both discipline,
+    description = `Determines indexing rules for pages filtered by both discipline,
 		and educational form (academic, semester, summer school, etc.).`;
     filterKeys = [FilterKey.DISCIPLINES, FilterKey.EDUCATIONAL_FORM];
     rules = [

package/dist/src/programmes/rules/ErasmusOrJointSpecialProgrammesRule.js

@@ -1,6 +1,6 @@
-import { FilterKey } from '@studyportals/search-filters';
-import { SpecialProgrammesFilterOptionValue } from '@studyportals/search-filters';
+import { FilterKey } from "../../enums/FilterKey";
 import { BaseProgrammeRule } from '../BaseProgrammeRule';
+import { SpecialProgrammesFilterOptionValue } from "../../enums/SpecialProgrammesFilterOptionValue";
 export class ErasmusOrJointSpecialProgrammesRule extends BaseProgrammeRule {
     forSearch(dependencies) {
         const { seoInfoBase, filterState } = dependencies;

package/dist/src/sitemap-generator/ISearchApiClient.d.ts

@@ -1,5 +1,14 @@
 import { FilterKeyValuesMap } from '../common/FilterKeyValuesMap';
 export interface ISearchApiClient {
     getOrganisationIds(): Promise<number[]>;
+    getCityIds?(): Promise<number[]>;
+    getCities(): Promise<{
+        id: number;
+        name: string;
+        virtualPath: string;
+        areaId: number | null;
+        countryIsoCode: string;
+    }[]>;
+    getProgrammeCount(filterKeyValues: FilterKeyValuesMap): Promise<number>;
     getCount(filterKeyValues: FilterKeyValuesMap): Promise<number>;
 }

package/dist/src/sitemap-generator/OrganisationsSitemapUrlGeneratorManager.js

@@ -1,6 +1,6 @@
 import { DependencyTypes } from '../enums/DependencyTypes';
 import { BaseSitemapUrlGeneratorManager } from './BaseSitemapUrlGeneratorManager';
-import { Area, AreaAttendance, Attendance, Continent, Country, CountryAttendance, RankedArea, RankedAreaDiscipline, RankedAttendance, RankedAttendanceDiscipline, RankedContinent, RankedContinentAttendance, RankedCountry, RankedCountryAttendance, RankedCountryDiscipline, RankedDiscipline, RankedUnfiltered, Unfiltered } from '../organisations/policies';
+import { City, Area, AreaAttendance, Attendance, Continent, Country, CountryAttendance, RankedArea, RankedAreaDiscipline, RankedAttendance, RankedAttendanceDiscipline, RankedContinent, RankedContinentAttendance, RankedCountry, RankedCountryAttendance, RankedCountryDiscipline, RankedDiscipline, RankedUnfiltered, Unfiltered } from '../organisations/policies';
 import { AreaPresenter } from '../presenters/AreaPresenter';
 import { AttendancePresenter } from '../presenters/AttendancePresenter';
 import { ContinentPresenter } from '../presenters/ContinentPresenter';
@@ -22,6 +22,7 @@ export class OrganisationsSitemapUrlGeneratorManager extends BaseSitemapUrlGener
             rankingApiClient
         };
         this.policies = [
+            new City(dependencies),
             new Area(dependencies),
             new AreaAttendance(dependencies),
             new Attendance(dependencies),

package/dist/src/structured-data/ScholarshipStructuredDataFactory.d.ts

@@ -0,0 +1,17 @@
+import { MonetaryGrant } from "schema-dts";
+import { StructuredDataCurrencyConversionService } from "./interface/StructuredDataCurrencyConversionService";
+import { SearchStructuredDataFactory } from "./SearchStructuredDataFactory";
+import { IScholarshipCard } from "@studyportals/domain-client";
+import { EntityDTO, OfferDTO, PaywallDTO } from "./dto";
+type MonetaryGrantWithPaywall = MonetaryGrant & {
+    isAccessibleForFree?: boolean;
+};
+export declare class ScholarshipStructuredDataFactory extends SearchStructuredDataFactory<IScholarshipCard> {
+    private currencyConversionService;
+    constructor(currencyConversionService: StructuredDataCurrencyConversionService);
+    protected buildStructuredDataForCard(entity: EntityDTO<IScholarshipCard>): Promise<MonetaryGrantWithPaywall | undefined>;
+    protected getOfferData(card: IScholarshipCard): Promise<OfferDTO | undefined>;
+    protected getPaywallData(): PaywallDTO | undefined;
+    private buildAmount;
+}
+export {};

package/dist/src/structured-data/ScholarshipStructuredDataFactory.js

@@ -0,0 +1,63 @@
+import { SearchStructuredDataFactory } from "./SearchStructuredDataFactory";
+export class ScholarshipStructuredDataFactory extends SearchStructuredDataFactory {
+    currencyConversionService;
+    constructor(currencyConversionService) {
+        super();
+        this.currencyConversionService = currencyConversionService;
+    }
+    async buildStructuredDataForCard(entity) {
+        const url = `https://${window.location.host}${entity.card.getScholarshipVirtualName()}`;
+        const amount = await this.buildAmount(entity.card);
+        const structuredData = {
+            "@type": "MonetaryGrant",
+            name: entity.card.getScholarshipTitle() || undefined,
+            description: entity.card.getDescriptionOfApplicationBasis() || undefined,
+            funder: entity.card.getProviderName() || undefined,
+            url,
+            amount
+        };
+        this.addPaywallToStructuredData(structuredData, entity.paywall);
+        return structuredData;
+    }
+    async getOfferData(card) {
+        const benefits = card.getDescriptionOfBenefits();
+        const hasMonetaryValue = benefits && !isNaN(Number(benefits.split(' ')[0]));
+        if (!hasMonetaryValue)
+            return;
+        const [amount, currency] = [Number(benefits.split(' ')[0]), benefits.split(' ')[1]];
+        return {
+            price: Math.round(await this.currencyConversionService.convert(amount, currency, 'USD')),
+            category: 'tuition',
+            validFrom: undefined
+        };
+    }
+    getPaywallData() {
+        return {
+            isAccessibleForFree: false,
+            cssSelector: '.Paywalled',
+            accessMode: 'registration'
+        };
+    }
+    async buildAmount(card) {
+        const benefits = card.getDescriptionOfBenefits();
+        const hasMonetaryValue = benefits && !isNaN(Number(benefits.split(' ')[0]));
+        let amount;
+        let currency;
+        if (hasMonetaryValue) {
+            [amount, currency] = [Number(benefits.split(' ')[0]), benefits.split(' ')[1]];
+        }
+        let value;
+        if (hasMonetaryValue) {
+            value = Math.round(await this.currencyConversionService.convert(amount, currency, 'USD'));
+            currency = 'USD';
+        }
+        else {
+            value = benefits || undefined;
+        }
+        return {
+            "@type": "MonetaryAmount",
+            value,
+            currency
+        };
+    }
+}

package/dist/src/structured-data/SearchStructuredDataFactory.d.ts

@@ -1,12 +1,14 @@
-import { SearchResultsPage, WithContext, Offer, AggregateRating, Thing, FAQPage } from 'schema-dts';
+import { SearchResultsPage, WithContext, Offer, AggregateRating, Thing, FAQPage, WebPage } from 'schema-dts';
 import { ReviewRatingDTO } from './dto/ReviewRatingDTO';
 import { OfferDTO } from './dto/OfferDTO';
 import { EntityDTO } from './dto/EntityDTO';
 import { FAQItemDto } from './dto/FAQItemDto';
 import { BreadcrumbDTO } from './dto/BreadcrumbDTO';
+import { PaywallDTO } from './dto/PaywallDTO';
 export declare abstract class SearchStructuredDataFactory<TCard> {
-    buildStructuredData(title: string, description: string, cards: TCard[], faqItems?: FAQItemDto[], breadcrumbs?: BreadcrumbDTO[]): Promise<WithContext<SearchResultsPage>>;
-    protected abstract buildStructuredDataForCard(entity: EntityDTO<TCard>): Thing | undefined;
+    buildStructuredData(title: string, description: string, cards: TCard[], faqItems?: FAQItemDto[], breadcrumbs?: BreadcrumbDTO[], listItemStructure?: boolean): Promise<WithContext<SearchResultsPage | WebPage>>;
+    private generateMainEntities;
+    protected abstract buildStructuredDataForCard(entity: EntityDTO<TCard>): Promise<Thing | undefined> | Thing | undefined;
     /**
      * Get the rating for a card.
      * This method should be overridden by subclasses to provide the specific rating logic.
@@ -25,10 +27,21 @@ export declare abstract class SearchStructuredDataFactory<TCard> {
      * @protected
      */
     protected getOfferData(card: TCard): Promise<OfferDTO | undefined>;
+    protected getPaywallData(): PaywallDTO | undefined;
     private constructOptionalPageOffers;
     protected constructOptionalFaqPage(faqItems: FAQItemDto[]): FAQPage | undefined;
+    private constructOptionalPageParts;
     private constructOptionalBreadcrumbs;
+    private constructPaywallElement;
     protected constructAggregateRating(reviewRating?: ReviewRatingDTO): AggregateRating | undefined;
     protected constructOffer(offerData?: OfferDTO): Offer | undefined;
+    /**
+     * Add paywall information to any structured data object
+     *
+     * @param structuredData The structured data object to enhance
+     * @param paywallData The paywall data to add
+     * @protected
+     */
+    protected addPaywallToStructuredData(structuredData: Record<string, any>, paywallData?: PaywallDTO): void;
     private stripHtmlWithListRetain;
 }

package/dist/src/structured-data/SearchStructuredDataFactory.js

@@ -1,5 +1,5 @@
 export class SearchStructuredDataFactory {
-    async buildStructuredData(title, description, cards, faqItems = [], breadcrumbs = []) {
+    async buildStructuredData(title, description, cards, faqItems = [], breadcrumbs = [], listItemStructure) {
         const entities = [];
         const ratings = [];
         const offersData = [];
@@ -12,21 +12,45 @@ export class SearchStructuredDataFactory {
                 offersData.push(offer);
             entities.push({ card, offer, reviewRating });
         }
-        const mainEntities = entities
-            .map(entity => this.buildStructuredDataForCard(entity))
-            .filter(entity => entity !== undefined);
+        const mainEntities = await this.generateMainEntities(entities, listItemStructure);
         const data = {
             '@context': 'https://schema.org',
-            '@type': 'SearchResultsPage',
+            '@type': !listItemStructure ? 'SearchResultsPage' : 'WebPage',
             'name': title,
             description,
             'mainEntity': mainEntities
         };
+        const paywallData = this.getPaywallData();
         data.offers = this.constructOptionalPageOffers(offersData);
-        data.hasPart = this.constructOptionalFaqPage(faqItems);
+        data.hasPart = this.constructOptionalPageParts(faqItems, paywallData);
         data.breadcrumb = this.constructOptionalBreadcrumbs(breadcrumbs);
+        if (paywallData) {
+            data.isAccessibleForFree = paywallData.isAccessibleForFree;
+        }
         return data;
     }
+    async generateMainEntities(entities, listItemStructure) {
+        const mainEntities = [];
+        for (const entity of entities) {
+            const structuredData = await this.buildStructuredDataForCard(entity);
+            if (!structuredData)
+                continue;
+            mainEntities.push(structuredData);
+        }
+        if (listItemStructure) {
+            const listItems = mainEntities.map((entity, index) => ({
+                '@type': 'ListItem',
+                'position': index + 1,
+                'item': entity
+            }));
+            return [{
+                    '@type': 'ItemList',
+                    'numberOfItems': mainEntities.length,
+                    'itemListElement': listItems
+                }];
+        }
+        return mainEntities;
+    }
     /**
      * Get the rating for a card.
      * This method should be overridden by subclasses to provide the specific rating logic.
@@ -48,7 +72,10 @@ export class SearchStructuredDataFactory {
      * @protected
      */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async getOfferData(card) {
+    getOfferData(card) {
+        return Promise.resolve(undefined);
+    }
+    getPaywallData() {
         return undefined;
     }
     constructOptionalPageOffers(offersData) {
@@ -94,6 +121,21 @@ export class SearchStructuredDataFactory {
             }))
         };
     }
+    constructOptionalPageParts(faqItems, paywallData) {
+        const parts = [];
+        const faqPage = this.constructOptionalFaqPage(faqItems);
+        if (faqPage) {
+            parts.push(faqPage);
+        }
+        if (paywallData && paywallData.cssSelector) {
+            parts.push(this.constructPaywallElement(paywallData));
+        }
+        if (parts.length === 0)
+            return undefined;
+        if (parts.length === 1 && parts[0]['@type'] === 'FAQPage')
+            return parts[0];
+        return parts;
+    }
     constructOptionalBreadcrumbs(breadcrumbs) {
         if (breadcrumbs.length <= 0)
             return;
@@ -108,6 +150,16 @@ export class SearchStructuredDataFactory {
             }))
         };
     }
+    constructPaywallElement(paywallData) {
+        const element = {
+            '@type': 'WebPageElement',
+            'isAccessibleForFree': paywallData.isAccessibleForFree
+        };
+        if (paywallData.cssSelector) {
+            element.cssSelector = paywallData.cssSelector;
+        }
+        return element;
+    }
     constructAggregateRating(reviewRating) {
         if (!reviewRating)
             return;
@@ -131,6 +183,18 @@ export class SearchStructuredDataFactory {
             'category': 'tuition'
         };
     }
+    /**
+     * Add paywall information to any structured data object
+     *
+     * @param structuredData The structured data object to enhance
+     * @param paywallData The paywall data to add
+     * @protected
+     */
+    addPaywallToStructuredData(structuredData, paywallData) {
+        if (!paywallData)
+            return;
+        structuredData.isAccessibleForFree = paywallData.isAccessibleForFree;
+    }
     stripHtmlWithListRetain(html) {
         const tempDiv = document.createElement('div');
         tempDiv.innerHTML = html;

package/dist/src/structured-data/dto/EntityDTO.d.ts

@@ -1,7 +1,9 @@
 import { OfferDTO } from "./OfferDTO";
 import { ReviewRatingDTO } from "./ReviewRatingDTO";
+import { PaywallDTO } from "./PaywallDTO";
 export interface EntityDTO<TCard> {
     card: TCard;
     offer?: OfferDTO;
     reviewRating?: ReviewRatingDTO;
+    paywall?: PaywallDTO;
 }

package/dist/src/structured-data/dto/PaywallDTO.d.ts

@@ -0,0 +1,14 @@
+export interface PaywallDTO {
+    /**
+     * Whether the content is behind a paywall
+     */
+    isAccessibleForFree: boolean;
+    /**
+     * CSS selector for the paywall element (optional)
+     */
+    cssSelector?: string;
+    /**
+     * Type of access restriction
+     */
+    accessMode?: 'subscription' | 'payment' | 'registration' | 'free';
+}

package/dist/src/structured-data/dto/index.d.ts

@@ -2,5 +2,6 @@ export * from './BreadcrumbDTO';
 export * from './EntityDTO';
 export * from './FAQItemDto';
 export * from './OfferDTO';
+export * from './PaywallDTO';
 export * from './ReviewRatingDTO';
 export * from './OrganisationDTO';

package/dist/src/structured-data/dto/index.js

@@ -2,5 +2,6 @@ export * from './BreadcrumbDTO';
 export * from './EntityDTO';
 export * from './FAQItemDto';
 export * from './OfferDTO';
+export * from './PaywallDTO';
 export * from './ReviewRatingDTO';
 export * from './OrganisationDTO';

package/dist/src/structured-data/index.d.ts

@@ -1,3 +1,4 @@
 export * from './ProgrammeStructuredDataFactory';
 export * from './OrganisationStructuredDataFactory';
+export * from './ScholarshipStructuredDataFactory';
 export * from './dto';

package/dist/src/structured-data/index.js

@@ -1,3 +1,4 @@
 export * from './ProgrammeStructuredDataFactory';
 export * from './OrganisationStructuredDataFactory';
+export * from './ScholarshipStructuredDataFactory';
 export * from './dto';