@studyportals/fawkes 8.0.1-0 → 8.0.1-2

package/dist/src/scholarships/types/IScholarshipSeoDependencies.d.ts

@@ -0,0 +1,3 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { IScholarshipSitemapDependencies } from './IScholarshipSitemapDependencies';
+export type IScholarshipSeoDependencies = ISearchDependencies | IScholarshipSitemapDependencies;

package/dist/src/scholarships/types/IScholarshipSeoDependencies.js

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

package/dist/src/scholarships/types/IScholarshipSitemapDependencies.d.ts

@@ -0,0 +1,5 @@
+import { ISitemapDependencies } from '../../common/ISitemapDependencies';
+import { IOrganisationsClient } from '../../sitemap-generator/IOrganisationsClient';
+export interface IScholarshipSitemapDependencies extends ISitemapDependencies {
+    organisationsClient: IOrganisationsClient;
+}

package/dist/src/scholarships/types/IScholarshipSitemapDependencies.js

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

package/dist/src/scholarships/types.d.ts

@@ -0,0 +1,5 @@
+export declare const types: {
+    SeoInfoBase: symbol;
+    SeoFilterState: symbol;
+    SeoApplicationState: symbol;
+};

package/dist/src/scholarships/types.js

@@ -0,0 +1,5 @@
+export const types = {
+    SeoInfoBase: Symbol.for('ISeoInfoBase'),
+    SeoFilterState: Symbol.for('ISeoFilterState'),
+    SeoApplicationState: Symbol.for('ISearchApplicationState')
+};

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

@@ -0,0 +1,14 @@
+import { ISitemapUrlGenerator } from '../common/ISitemapUrlGenerator';
+import { ISitemapUrlGeneratorManager } from './ISitemapUrlGeneratorManager';
+import { FilterCombinations } from '../enums/FilterCombinations';
+import { IPresenter } from '../common';
+import { FilterKey } from '@studyportals/search-filters';
+export declare abstract class BaseSitemapUrlGeneratorManager implements ISitemapUrlGeneratorManager {
+    abstract readonly policies: ISitemapUrlGenerator[];
+    abstract readonly presenters: Map<FilterKey, IPresenter>;
+    protected readonly filterKeyValueCounts: Map<FilterKey, number>;
+    generateUrls(): Promise<Map<FilterCombinations, string[]>>;
+    getFilterKeyValueCounts(): Map<FilterKey, number>;
+    protected setFilterKeyValueCounts(): void;
+    getPolicies(): ISitemapUrlGenerator[];
+}

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

@@ -0,0 +1,26 @@
+export class BaseSitemapUrlGeneratorManager {
+    filterKeyValueCounts = new Map();
+    async generateUrls() {
+        const map = new Map();
+        for (const policy of this.policies) {
+            console.debug(`Generating sitemap urls for policy: ${policy.filterCombination}`); // eslint-disable-line no-console
+            const filterCombination = policy.filterCombination;
+            const urls = await policy.generateSitemapUrls();
+            console.debug(`Generated ${urls.length} urls for policy: ${filterCombination}`); // eslint-disable-line no-console
+            map.set(filterCombination, urls);
+        }
+        return map;
+    }
+    getFilterKeyValueCounts() {
+        return this.filterKeyValueCounts;
+    }
+    setFilterKeyValueCounts() {
+        for (const presenter of this.presenters.values()) {
+            const count = presenter.getFragments().length;
+            this.filterKeyValueCounts.set(presenter.filterKey, count);
+        }
+    }
+    getPolicies() {
+        return this.policies;
+    }
+}

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

@@ -0,0 +1,6 @@
+export interface IOrganisation {
+    readonly id: number;
+    readonly name: string;
+    readonly virtualPath: string;
+    readonly countryIsoCodes: string[];
+}

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

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

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

@@ -0,0 +1,4 @@
+import { IOrganisation } from './IOrganisation';
+export interface IOrganisationsClient {
+    getOrganisations(ids: number[]): Promise<IOrganisation[]>;
+}

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

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

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

@@ -0,0 +1,4 @@
+import { FilterKeyValuesMap } from '../common/FilterKeyValuesMap';
+export interface IRankingApiClient {
+    getRankedOrganisationCount(filterKeyValues: FilterKeyValuesMap): Promise<number>;
+}

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

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

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

@@ -0,0 +1,5 @@
+import { FilterKeyValuesMap } from '../common/FilterKeyValuesMap';
+export interface ISearchApiClient {
+    getOrganisationIds(): Promise<number[]>;
+    getCount(filterKeyValues: FilterKeyValuesMap): Promise<number>;
+}

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

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

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

@@ -0,0 +1,9 @@
+import { IDocumentationManager } from '../common/IDocumentationManager';
+import { FilterCombinations } from '../enums/FilterCombinations';
+import { IPresenter } from '../common';
+import { FilterKey } from '@studyportals/search-filters';
+export interface ISitemapUrlGeneratorManager extends IDocumentationManager {
+    readonly presenters: Map<FilterKey, IPresenter>;
+    generateUrls(): Promise<Map<FilterCombinations, string[]>>;
+    getFilterKeyValueCounts(): Map<FilterKey, number>;
+}

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

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

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

@@ -0,0 +1,14 @@
+import { ISitemapUrlGenerator } from '../common/ISitemapUrlGenerator';
+import { IOrganisationsClient } from '../sitemap-generator/IOrganisationsClient';
+import { ISearchApiClient } from '../sitemap-generator/ISearchApiClient';
+import { BaseSitemapUrlGeneratorManager } from './BaseSitemapUrlGeneratorManager';
+import { PortalType } from '@studyportals/domain-client';
+import { IRankingApiClient } from './IRankingApiClient';
+import { FilterKey } from '@studyportals/search-filters';
+import { IPresenter } from '../common';
+export declare class OrganisationsSitemapUrlGeneratorManager extends BaseSitemapUrlGeneratorManager {
+    readonly portalType: PortalType;
+    readonly policies: ISitemapUrlGenerator[];
+    readonly presenters: Map<FilterKey, IPresenter>;
+    constructor(portalType: PortalType, searchApiClient: ISearchApiClient, organisationsClient: IOrganisationsClient, rankingApiClient: IRankingApiClient);
+}

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

@@ -0,0 +1,51 @@
+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 { AreaPresenter } from '../presenters/AreaPresenter';
+import { AttendancePresenter } from '../presenters/AttendancePresenter';
+import { ContinentPresenter } from '../presenters/ContinentPresenter';
+import { CountryPresenter } from '../presenters/CountryPresenter';
+import { DisciplinePresenter } from '../presenters/DisciplinePresenter';
+import { FilterKey } from '@studyportals/search-filters';
+export class OrganisationsSitemapUrlGeneratorManager extends BaseSitemapUrlGeneratorManager {
+    portalType;
+    policies;
+    presenters = new Map();
+    constructor(portalType, searchApiClient, organisationsClient, rankingApiClient) {
+        super();
+        this.portalType = portalType;
+        const dependencies = {
+            dependencyType: DependencyTypes.SITEMAP_GENERATOR,
+            portalType,
+            searchApiClient,
+            organisationsClient,
+            rankingApiClient
+        };
+        this.policies = [
+            new Area(dependencies),
+            new AreaAttendance(dependencies),
+            new Attendance(dependencies),
+            new Continent(dependencies),
+            new Country(dependencies),
+            new CountryAttendance(dependencies),
+            new Unfiltered(dependencies),
+            new RankedArea(dependencies),
+            new RankedAreaDiscipline(dependencies),
+            new RankedAttendance(dependencies),
+            new RankedAttendanceDiscipline(dependencies),
+            new RankedContinent(dependencies),
+            new RankedContinentAttendance(dependencies),
+            new RankedCountry(dependencies),
+            new RankedCountryAttendance(dependencies),
+            new RankedCountryDiscipline(dependencies),
+            new RankedDiscipline(dependencies),
+            new RankedUnfiltered(dependencies)
+        ];
+        this.presenters.set(FilterKey.AREA, AreaPresenter.getInstance());
+        this.presenters.set(FilterKey.DELIVERY_METHOD, AttendancePresenter.getInstance());
+        this.presenters.set(FilterKey.CONTINENT, ContinentPresenter.getInstance());
+        this.presenters.set(FilterKey.COUNTRY, CountryPresenter.getInstance());
+        this.presenters.set(FilterKey.DISCIPLINES, DisciplinePresenter.getInstance());
+        this.setFilterKeyValueCounts();
+    }
+}

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

@@ -0,0 +1,12 @@
+import { ISearchApiClient } from '../sitemap-generator/ISearchApiClient';
+import { BaseSitemapUrlGeneratorManager } from './BaseSitemapUrlGeneratorManager';
+import { PortalType } from '@studyportals/domain-client';
+import { FilterKey } from '@studyportals/search-filters';
+import { IPresenter } from '../common';
+import { IProgrammeSitemapUrlGenerator } from '../programmes/types/IProgrammeSitemapUrlGenerator';
+export declare class ProgrammesSitemapUrlGeneratorManager extends BaseSitemapUrlGeneratorManager {
+    readonly portalType: PortalType;
+    readonly policies: IProgrammeSitemapUrlGenerator[];
+    readonly presenters: Map<FilterKey, IPresenter>;
+    constructor(portalType: PortalType, searchApiClient: ISearchApiClient);
+}

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

@@ -0,0 +1,77 @@
+import { DependencyTypes } from '../enums/DependencyTypes';
+import { BaseSitemapUrlGeneratorManager } from './BaseSitemapUrlGeneratorManager';
+import { Area, Attendance, AttendanceDegree, Continent, ContinentTuitionFee, Country, CountryAttendance, Discipline, SpecialProgrammes, TuitionFee, Unfiltered, CountryAttendanceDegree, CountryDuration, CountryDurationDegree, CountryEducationalForm, CountryFormat, CountryTuitionFee, DegreeAttendanceDiscipline, DegreeCountryAttendance, DegreeCountryDiscipline, DegreeCountryTuitionFee, DisciplineArea, DisciplineAttendance, DisciplineContinent, DisciplineCountry, DisciplineCountryEducationalForm, DisciplineDegree, DisciplineDuration, DisciplineEducationalForm, DisciplineFormat, DisciplineTuitionFee, DisciplineTuitionFeeAttendance, CountryDegree } from '../programmes/policies';
+import { FilterKey } from '@studyportals/search-filters';
+import { AreaPresenter } from '../presenters/AreaPresenter';
+import { AttendancePresenter } from '../presenters/AttendancePresenter';
+import { DegreePresenter } from '../presenters/DegreePresenter';
+import { ContinentPresenter } from '../presenters/ContinentPresenter';
+import { TuitionFeePresenter } from '../presenters/TuitionFeePresenter';
+import { CountryPresenter } from '../presenters/CountryPresenter';
+import { DisciplinePresenter } from '../presenters/DisciplinePresenter';
+import { SpecialProgrammesPresenter } from '../presenters/SpecialProgrammesPresenter';
+import { DurationPresenter } from '../presenters/DurationPresenter';
+import { EducationalFormPresenter } from '../presenters/EducationalFormPresenter';
+import { FormatPresenter } from '../presenters/FormatPresenter';
+import { Degree } from '../programmes/policies/Degree';
+export class ProgrammesSitemapUrlGeneratorManager extends BaseSitemapUrlGeneratorManager {
+    portalType;
+    policies;
+    presenters = new Map();
+    constructor(portalType, searchApiClient) {
+        super();
+        this.portalType = portalType;
+        const dependencies = {
+            dependencyType: DependencyTypes.SITEMAP_GENERATOR,
+            searchApiClient,
+            portalType
+        };
+        this.policies = [
+            new Area(dependencies),
+            new Attendance(dependencies),
+            new AttendanceDegree(dependencies),
+            new Continent(dependencies),
+            new ContinentTuitionFee(dependencies),
+            new Country(dependencies),
+            new CountryAttendance(dependencies),
+            new Discipline(dependencies),
+            new Degree(dependencies),
+            new SpecialProgrammes(dependencies),
+            new TuitionFee(dependencies),
+            new Unfiltered(dependencies),
+            new CountryAttendanceDegree(dependencies),
+            new CountryDegree(dependencies),
+            new CountryDuration(dependencies),
+            new CountryDurationDegree(dependencies),
+            new CountryEducationalForm(dependencies),
+            new CountryFormat(dependencies),
+            new CountryTuitionFee(dependencies),
+            new DegreeAttendanceDiscipline(dependencies),
+            new DegreeCountryAttendance(dependencies),
+            new DegreeCountryDiscipline(dependencies),
+            new DegreeCountryTuitionFee(dependencies),
+            new DisciplineArea(dependencies),
+            new DisciplineAttendance(dependencies),
+            new DisciplineContinent(dependencies),
+            new DisciplineCountry(dependencies),
+            new DisciplineCountryEducationalForm(dependencies),
+            new DisciplineDegree(dependencies),
+            new DisciplineDuration(dependencies),
+            new DisciplineEducationalForm(dependencies),
+            new DisciplineFormat(dependencies),
+            new DisciplineTuitionFee(dependencies),
+            new DisciplineTuitionFeeAttendance(dependencies)
+        ];
+        this.presenters.set(FilterKey.AREA, AreaPresenter.getInstance());
+        this.presenters.set(FilterKey.DELIVERY_METHOD, AttendancePresenter.getInstance());
+        this.presenters.set(FilterKey.DEGREE_TYPE, DegreePresenter.getInstance());
+        this.presenters.set(FilterKey.CONTINENT, ContinentPresenter.getInstance());
+        this.presenters.set(FilterKey.TUITION_FEE, TuitionFeePresenter.getInstance());
+        this.presenters.set(FilterKey.COUNTRY, CountryPresenter.getInstance());
+        this.presenters.set(FilterKey.DISCIPLINES, DisciplinePresenter.getInstance());
+        this.presenters.set(FilterKey.SPECIAL_PROGRAMMES, SpecialProgrammesPresenter.getInstance());
+        this.presenters.set(FilterKey.DURATION, DurationPresenter.getInstance());
+        this.presenters.set(FilterKey.EDUCATIONAL_FORM, EducationalFormPresenter.getInstance());
+        this.presenters.set(FilterKey.ATTENDANCE, FormatPresenter.getInstance());
+    }
+}

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

@@ -0,0 +1,9 @@
+import { ISitemapUrlGenerator } from '../common/ISitemapUrlGenerator';
+import { IOrganisationsClient } from '../sitemap-generator/IOrganisationsClient';
+import { ISearchApiClient } from '../sitemap-generator/ISearchApiClient';
+import { BaseSitemapUrlGeneratorManager } from './BaseSitemapUrlGeneratorManager';
+export declare class ScholarshipsSitemapUrlGeneratorManager extends BaseSitemapUrlGeneratorManager {
+    readonly policies: ISitemapUrlGenerator[];
+    readonly presenters: Map<any, any>;
+    constructor(searchApiClient: ISearchApiClient, organisationsClient: IOrganisationsClient);
+}

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

@@ -0,0 +1,28 @@
+import { DependencyTypes } from '../enums/DependencyTypes';
+import { Area } from '../scholarships/policies/Area';
+import { Country } from '../scholarships/policies/Country';
+import { Discipline } from '../scholarships/policies/Discipline';
+import { DisciplineCountry } from '../scholarships/policies/DisciplineCountry';
+import { UniversityCountry } from '../scholarships/policies/UniversityCountry';
+import { Unfiltered } from '../scholarships/policies/Unfiltered';
+import { BaseSitemapUrlGeneratorManager } from './BaseSitemapUrlGeneratorManager';
+export class ScholarshipsSitemapUrlGeneratorManager extends BaseSitemapUrlGeneratorManager {
+    policies;
+    presenters = new Map();
+    constructor(searchApiClient, organisationsClient) {
+        super();
+        const dependencies = {
+            dependencyType: DependencyTypes.SITEMAP_GENERATOR,
+            searchApiClient,
+            organisationsClient
+        };
+        this.policies = [
+            new Area(dependencies),
+            new Country(dependencies),
+            new DisciplineCountry(dependencies),
+            new Discipline(dependencies),
+            new UniversityCountry(dependencies),
+            new Unfiltered(dependencies)
+        ];
+    }
+}

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

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,18 @@
+import { SearchStructuredDataFactory } from "./SearchStructuredDataFactory";
+import { IProgrammeCard } from "@studyportals/domain-client";
+import { ReviewRatingDTO } from "./dto/ReviewRatingDTO";
+import { OfferDTO } from "./dto/OfferDTO";
+import { Course } from "schema-dts";
+import { EntityDTO } from "./dto/EntityDTO";
+import { StructuredDataCurrencyConversionService } from "../structured-data/interface/StructuredDataCurrencyConversionService";
+export declare class ProgrammeStructuredDataFactory extends SearchStructuredDataFactory<IProgrammeCard> {
+    private currencyConversionService;
+    constructor(currencyConversionService: StructuredDataCurrencyConversionService);
+    private regionalDataPriority;
+    protected getRating(card: IProgrammeCard): ReviewRatingDTO | undefined;
+    protected getOfferData(card: IProgrammeCard): Promise<OfferDTO | undefined>;
+    protected buildStructuredDataForCard(entity: EntityDTO<IProgrammeCard>): Course | undefined;
+    private getCourseMode;
+    private getCourseWorkload;
+    private getCourseStartDate;
+}

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

@@ -0,0 +1,91 @@
+import { SearchStructuredDataFactory } from "./SearchStructuredDataFactory";
+export class ProgrammeStructuredDataFactory extends SearchStructuredDataFactory {
+    currencyConversionService;
+    constructor(currencyConversionService) {
+        super();
+        this.currencyConversionService = currencyConversionService;
+    }
+    regionalDataPriority = ['international', 'general', 'eea', 'national'];
+    getRating(card) {
+        if (typeof card.getReviewRating === 'undefined')
+            return;
+        const rating = card.getReviewRating();
+        if (!rating || !rating.hasEnoughQuantity())
+            return;
+        return {
+            rating: rating?.getAverageStarRating(),
+            quantity: rating?.getQuantity(),
+        };
+    }
+    async getOfferData(card) {
+        if (!card.canShowTuitionFees())
+            return;
+        const tuitionFees = card.getTuitionFees();
+        let tuition;
+        let timing;
+        for (const target of this.regionalDataPriority) {
+            if (!tuition) {
+                tuition = tuitionFees.find(t => t.getTarget() === target);
+            }
+            if (!timing) {
+                timing = card.canShowTimings() ? card.getTimings().find(t => t.getType() === target && t.canShowStartDate()) : undefined;
+            }
+        }
+        if (!tuition) {
+            return;
+        }
+        return {
+            price: Math.round(await this.currencyConversionService.convert(tuition.getAmount(), tuition.getCurrency(), 'USD')),
+            category: 'tuition',
+            validFrom: timing ? timing.getStartDate().getDate() : undefined
+        };
+    }
+    buildStructuredDataForCard(entity) {
+        const offer = this.constructOffer(entity.offer);
+        if (!offer)
+            return undefined;
+        const card = entity.card;
+        return {
+            "@type": "Course",
+            "name": card.getTitle(),
+            "description": card.getSummary(),
+            "url": card.getProgrammeLink().getUrl(),
+            "provider": {
+                "@type": "EducationalOrganization",
+                "name": card.getUniversityLink().getDescription(),
+                "url": `https://${window.location.host}${card.getUniversityLink().getUrl()}`
+            },
+            "offers": offer,
+            "aggregateRating": this.constructAggregateRating(entity.reviewRating),
+            "hasCourseInstance": {
+                "@type": "CourseInstance",
+                "startDate": this.getCourseStartDate(card),
+                "courseWorkload": this.getCourseWorkload(card),
+                "courseMode": this.getCourseMode(card),
+            }
+        };
+    }
+    getCourseMode(card) {
+        if (card.isBlended())
+            return 'blended';
+        if (card.isOnline())
+            return 'online';
+        if (card.isOnCampus())
+            return 'onsite';
+    }
+    getCourseWorkload(card) {
+        if (card.isFullTime())
+            return 'PT40H';
+        if (card.isPartTime())
+            return 'PT20H';
+        return undefined;
+    }
+    getCourseStartDate(card) {
+        for (const target of this.regionalDataPriority) {
+            const timing = card.canShowTimings() ? card.getTimings().find(t => t.getType() === target && t.canShowStartDate()) : undefined;
+            if (timing) {
+                return timing.getStartDate().getDate().toISOString().split('T')[0];
+            }
+        }
+    }
+}

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

@@ -0,0 +1,34 @@
+import { SearchResultsPage, WithContext, Offer, AggregateRating, Thing, FAQPage } 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';
+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;
+    /**
+     * Get the rating for a card.
+     * This method should be overridden by subclasses to provide the specific rating logic.
+     * If no rating is available, return undefined and no aggregate rating will be constructed for the card & page.
+     *
+     * @param card
+     * @protected
+     */
+    protected getRating(card: TCard): ReviewRatingDTO | undefined;
+    /**
+     * Get the offer data for a card.
+     * This method should be overridden by subclasses to provide the specific offer logic.
+     * If no offer is available, return undefined and no aggregate offer will be constructed for the card & page.
+     *
+     * @param card
+     * @protected
+     */
+    protected getOfferData(card: TCard): Promise<OfferDTO | undefined>;
+    private constructOptionalPageOffers;
+    protected constructOptionalFaqPage(faqItems: FAQItemDto[]): FAQPage | undefined;
+    private constructOptionalBreadcrumbs;
+    protected constructAggregateRating(reviewRating?: ReviewRatingDTO): AggregateRating | undefined;
+    protected constructOffer(offerData?: OfferDTO): Offer | undefined;
+    private stripHtmlWithListRetain;
+}

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

@@ -0,0 +1,144 @@
+export class SearchStructuredDataFactory {
+    async buildStructuredData(title, description, cards, faqItems = [], breadcrumbs = []) {
+        const entities = [];
+        const ratings = [];
+        const offersData = [];
+        for (const card of cards) {
+            const reviewRating = this.getRating(card);
+            const offer = await this.getOfferData(card);
+            if (reviewRating)
+                ratings.push(reviewRating);
+            if (offer)
+                offersData.push(offer);
+            entities.push({ card, offer, reviewRating });
+        }
+        const mainEntities = entities
+            .map(entity => this.buildStructuredDataForCard(entity))
+            .filter(entity => entity !== undefined);
+        const data = {
+            '@context': 'https://schema.org',
+            '@type': 'SearchResultsPage',
+            'name': title,
+            description,
+            'mainEntity': mainEntities
+        };
+        data.offers = this.constructOptionalPageOffers(offersData);
+        data.hasPart = this.constructOptionalFaqPage(faqItems);
+        data.breadcrumb = this.constructOptionalBreadcrumbs(breadcrumbs);
+        return data;
+    }
+    /**
+     * Get the rating for a card.
+     * This method should be overridden by subclasses to provide the specific rating logic.
+     * If no rating is available, return undefined and no aggregate rating will be constructed for the card & page.
+     *
+     * @param card
+     * @protected
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getRating(card) {
+        return undefined;
+    }
+    /**
+     * Get the offer data for a card.
+     * This method should be overridden by subclasses to provide the specific offer logic.
+     * If no offer is available, return undefined and no aggregate offer will be constructed for the card & page.
+     *
+     * @param card
+     * @protected
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async getOfferData(card) {
+        return undefined;
+    }
+    constructOptionalPageOffers(offersData) {
+        if (offersData.length <= 0)
+            return;
+        let minPrice = -1;
+        let maxPrice = 0;
+        let totalPrice = 0;
+        for (const offer of offersData) {
+            if (offer.price < minPrice || minPrice === -1) {
+                minPrice = offer.price;
+            }
+            if (offer.price > maxPrice) {
+                maxPrice = offer.price;
+            }
+            totalPrice += offer.price;
+        }
+        return {
+            '@type': 'AggregateOffer',
+            'lowPrice': Math.max(minPrice, 0),
+            'highPrice': maxPrice,
+            'priceCurrency': 'USD',
+            'offerCount': offersData.length,
+            'priceSpecification': {
+                '@type': 'PriceSpecification',
+                'price': Math.round(totalPrice / offersData.length),
+                'priceCurrency': 'USD'
+            }
+        };
+    }
+    constructOptionalFaqPage(faqItems) {
+        if (faqItems.length <= 0)
+            return;
+        return {
+            '@type': 'FAQPage',
+            'mainEntity': faqItems.map(item => ({
+                '@type': 'Question',
+                'name': item.question,
+                'acceptedAnswer': {
+                    '@type': 'Answer',
+                    'text': this.stripHtmlWithListRetain(item.answer)
+                }
+            }))
+        };
+    }
+    constructOptionalBreadcrumbs(breadcrumbs) {
+        if (breadcrumbs.length <= 0)
+            return;
+        return {
+            '@type': 'BreadcrumbList',
+            'itemListElement': breadcrumbs.map((breadcrumb) => ({
+                '@type': 'ListItem',
+                '@id': `${breadcrumb.url}#listitem#thing`,
+                'name': breadcrumb.name,
+                'position': breadcrumb.position,
+                'item': breadcrumb.url
+            }))
+        };
+    }
+    constructAggregateRating(reviewRating) {
+        if (!reviewRating)
+            return;
+        return {
+            '@type': 'AggregateRating',
+            'ratingValue': reviewRating.rating,
+            'reviewCount': reviewRating.quantity,
+            'bestRating': 5,
+            'worstRating': 1
+        };
+    }
+    constructOffer(offerData) {
+        if (!offerData)
+            return;
+        return {
+            '@type': 'Offer',
+            'price': offerData.price,
+            'priceCurrency': 'USD',
+            'availability': 'https://schema.org/InStock',
+            'validFrom': offerData.validFrom ? offerData.validFrom.toISOString().split('T')[0] : undefined,
+            'category': 'tuition'
+        };
+    }
+    stripHtmlWithListRetain(html) {
+        const tempDiv = document.createElement('div');
+        tempDiv.innerHTML = html;
+        // Replace all <li> elements with bullet points manually
+        tempDiv.querySelectorAll('li').forEach(li => {
+            li.textContent = '• ' + li.textContent;
+        });
+        // Get the text content, which includes newlines for block elements
+        return tempDiv.textContent?.trim() ?? '';
+    }
+}

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

@@ -0,0 +1,5 @@
+export interface BreadcrumbDTO {
+    name: string;
+    position: number;
+    url: string;
+}

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

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

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

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

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

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