@studyportals/fawkes 8.1.2-2 → 8.1.2-4

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

@@ -0,0 +1,41 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfArtsDisciplineRule extends BaseProgrammeRule {
+    // Master of Arts accepts all disciplines
+    degreeValue = 'master-of-arts';
+    getName() {
+        return 'MasterOfArtsDisciplineRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-arts + all disciplines';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const disciplineValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DISCIPLINES, filterState);
+        // This rule only applies to Master of Arts
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true); // Rule doesn't apply to other degrees
+        }
+        // Must have a discipline selected
+        if (!disciplineValue) {
+            return Promise.resolve(false);
+        }
+        // Master of Arts accepts all disciplines
+        return Promise.resolve(true);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const disciplineValues = filterKeyValues.get(FilterKey.DISCIPLINES);
+        if (!degreeTypeValues?.length || !disciplineValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        // This rule only applies to Master of Arts
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true); // Rule doesn't apply to other degrees
+        }
+        // Master of Arts accepts all disciplines
+        return Promise.resolve(true);
+    }
+}

package/dist/src/programmes/rules/MasterOfEducationCountryDisciplineRule.d.ts

@@ -0,0 +1,11 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class MasterOfEducationCountryDisciplineRule extends BaseProgrammeRule {
+    private readonly educationDisciplineIds;
+    private readonly allowedCountryIds;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

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

@@ -0,0 +1,69 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { DegreeTypeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfEducationCountryDisciplineRule extends BaseProgrammeRule {
+    educationDisciplineIds = [
+        '289', // Education & Training (main discipline)
+        '290', // Adult Education
+        '360', // Art Education
+        '291', // Coaching
+        '292', // School Counselling
+        '333', // Early Childhood Education
+        '8', // Education
+        '349', // Educational Leadership
+        '293', // Educational Psychology
+        '98', // Educational Research
+        '371', // Health Education
+        '363', // Higher Education
+        '355', // Instructional Design
+        '370', // Literacy Education
+        '348', // Primary Education
+        '97', // Special Education
+        '359', // Secondary Education
+        '345', // STEM Education
+        '295', // Teaching
+        '358' // Teaching English as a Foreign Language
+    ];
+    // Australia (202), Canada (32)
+    allowedCountryIds = ['202', '32'];
+    getName() {
+        return 'MasterOfEducationCountryDisciplineRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-education (Australia, Canada) + education disciplines only';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const countryValue = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        const disciplineValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DISCIPLINES, filterState);
+        if (degreeTypeValue !== DegreeTypeFilterOptionValue.MED) {
+            return Promise.resolve(true);
+        }
+        if (!countryValue || !disciplineValue) {
+            return Promise.resolve(false);
+        }
+        if (!this.allowedCountryIds.includes(countryValue)) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.educationDisciplineIds.includes(disciplineValue));
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        const disciplineValues = filterKeyValues.get(FilterKey.DISCIPLINES);
+        if (!degreeTypeValues?.length || !countryValues?.length || !disciplineValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const countryValue = countryValues[0];
+        const disciplineValue = disciplineValues[0];
+        if (degreeTypeValue !== DegreeTypeFilterOptionValue.MED.valueOf()) {
+            return Promise.resolve(true);
+        }
+        if (!this.allowedCountryIds.includes(countryValue)) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.educationDisciplineIds.includes(disciplineValue));
+    }
+}

package/dist/src/programmes/rules/MasterOfLawsCountryAttendanceRule.d.ts

@@ -0,0 +1,12 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class MasterOfLawsCountryAttendanceRule extends BaseProgrammeRule {
+    private readonly degreeValue;
+    private readonly attendanceValue;
+    private readonly allowedCountryIds;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

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

@@ -0,0 +1,43 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfLawsCountryAttendanceRule extends BaseProgrammeRule {
+    degreeValue = 'master-of-laws';
+    attendanceValue = 'online';
+    allowedCountryIds = ['82', '30', '32', '108'];
+    getName() {
+        return 'MasterOfLawsCountryAttendanceRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-laws (USA, UK, Canada, India) + online attendance';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const countryValue = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        const attendanceValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DELIVERY_METHOD, filterState);
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        if (!countryValue || !attendanceValue) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            attendanceValue === this.attendanceValue);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        const attendanceValues = filterKeyValues.get(FilterKey.DELIVERY_METHOD);
+        if (!degreeTypeValues?.length || !countryValues?.length || !attendanceValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const countryValue = countryValues[0];
+        const attendanceValue = attendanceValues[0];
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            attendanceValue === this.attendanceValue);
+    }
+}

package/dist/src/programmes/rules/MasterOfLawsCountryTuitionFeeRule.d.ts

@@ -0,0 +1,12 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class MasterOfLawsCountryTuitionFeeRule extends BaseProgrammeRule {
+    private readonly degreeValue;
+    private readonly allowedCountryIds;
+    private readonly tuitionFeeValue;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

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

@@ -0,0 +1,46 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { TuitionFeeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfLawsCountryTuitionFeeRule extends BaseProgrammeRule {
+    degreeValue = 'master-of-laws';
+    allowedCountryIds = ['82', '30', '32', '108']; // USA, UK, Canada, India
+    tuitionFeeValue = TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED;
+    getName() {
+        return 'MasterOfLawsCountryTuitionFeeRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-laws (USA, UK, Canada, India) + affordable tuition (0-2500)';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const countryValue = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        const tuitionFeeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.TUITION_FEE, filterState);
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        if (!countryValue || !tuitionFeeValue) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            tuitionFeeValue === this.tuitionFeeValue);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        const tuitionFeeValues = filterKeyValues.get(FilterKey.TUITION_FEE);
+        if (!degreeTypeValues?.length || !countryValues?.length || !tuitionFeeValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const countryValue = countryValues[0];
+        const tuitionFeeValue = tuitionFeeValues[0];
+        // This rule only applies to Master of Laws
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true); // Rule doesn't apply to other degrees
+        }
+        // Must be in allowed countries and have affordable tuition
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            tuitionFeeValue === this.tuitionFeeValue);
+    }
+}

package/dist/src/programmes/rules/MasterOfPhilosophyCountryAttendanceRule.d.ts

@@ -0,0 +1,12 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class MasterOfPhilosophyCountryAttendanceRule extends BaseProgrammeRule {
+    private readonly degreeValue;
+    private readonly attendanceValue;
+    private readonly allowedCountryIds;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

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

@@ -0,0 +1,43 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfPhilosophyCountryAttendanceRule extends BaseProgrammeRule {
+    degreeValue = 'master-of-philosophy';
+    attendanceValue = 'online';
+    allowedCountryIds = ['82', '30', '108']; // USA, UK, India
+    getName() {
+        return 'MasterOfPhilosophyCountryAttendanceRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-philosophy (USA, UK, India) + online attendance';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const countryValue = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        const attendanceValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DELIVERY_METHOD, filterState);
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        if (!countryValue || !attendanceValue) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            attendanceValue === this.attendanceValue);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        const attendanceValues = filterKeyValues.get(FilterKey.DELIVERY_METHOD);
+        if (!degreeTypeValues?.length || !countryValues?.length || !attendanceValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const countryValue = countryValues[0];
+        const attendanceValue = attendanceValues[0];
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            attendanceValue === this.attendanceValue);
+    }
+}

package/dist/src/programmes/rules/MasterOfScienceDisciplineRule.d.ts

@@ -0,0 +1,10 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class MasterOfScienceDisciplineRule extends BaseProgrammeRule {
+    private readonly degreeValue;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

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

@@ -0,0 +1,41 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfScienceDisciplineRule extends BaseProgrammeRule {
+    // Master of Science accepts all disciplines
+    degreeValue = 'master-of-science';
+    getName() {
+        return 'MasterOfScienceDisciplineRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-science + all disciplines';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const disciplineValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DISCIPLINES, filterState);
+        // This rule only applies to Master of Science
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true); // Rule doesn't apply to other degrees
+        }
+        // Must have a discipline selected
+        if (!disciplineValue) {
+            return Promise.resolve(false);
+        }
+        // Master of Science accepts all disciplines
+        return Promise.resolve(true);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const disciplineValues = filterKeyValues.get(FilterKey.DISCIPLINES);
+        if (!degreeTypeValues?.length || !disciplineValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        // This rule only applies to Master of Science
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true); // Rule doesn't apply to other degrees
+        }
+        // Master of Science accepts all disciplines
+        return Promise.resolve(true);
+    }
+}

package/dist/src/programmes/rules/OneOrTwoYearDurationRule.d.ts

@@ -0,0 +1,6 @@
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export declare class OneOrTwoYearDurationRule extends BaseProgrammeFilterKeyValueRule {
+    constructor();
+    getName(): string;
+    getDescription(): string;
+}

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

@@ -0,0 +1,19 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { DurationFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export class OneOrTwoYearDurationRule extends BaseProgrammeFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([[
+                FilterKey.DURATION,
+                [DurationFilterOptionValue.ONE_YEAR, DurationFilterOptionValue.TWO_YEARS]
+            ]
+        ]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'OneOrTwoYearDurationRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected duration is one or two years.';
+    }
+}

package/dist/src/programmes/rules/OneYearOnlyRule.d.ts

@@ -0,0 +1,11 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class OneYearOnlyRule extends BaseProgrammeRule {
+    constructor();
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+    getName(): string;
+    getDescription(): string;
+    private isOneYear;
+}

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

@@ -0,0 +1,34 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { DurationFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class OneYearOnlyRule extends BaseProgrammeRule {
+    constructor() {
+        super();
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const selectedDuration = seoInfoBase.getFilterOptionValueBy(FilterKey.DURATION, filterState);
+        if (!selectedDuration) {
+            return Promise.resolve(false);
+        }
+        const isOneYear = this.isOneYear(selectedDuration);
+        return Promise.resolve(isOneYear);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const [selectedDuration] = filterKeyValues.get(FilterKey.DURATION);
+        if (!selectedDuration) {
+            return Promise.resolve(false);
+        }
+        const isOneYear = this.isOneYear(selectedDuration);
+        return Promise.resolve(isOneYear);
+    }
+    getName() {
+        return 'OneYearOnlyRule';
+    }
+    getDescription() {
+        return 'Indexable only if duration is exactly 1 year ([360,360]).';
+    }
+    isOneYear(value) {
+        return value === DurationFilterOptionValue.ONE_YEAR;
+    }
+}

package/dist/src/programmes/rules/OnlineAttendanceRule.d.ts

@@ -0,0 +1,6 @@
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export declare class OnlineAttendanceRule extends BaseProgrammeFilterKeyValueRule {
+    constructor();
+    getName(): string;
+    getDescription(): string;
+}

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

@@ -0,0 +1,15 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { AttendanceFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export class OnlineAttendanceRule extends BaseProgrammeFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([[FilterKey.DELIVERY_METHOD, [AttendanceFilterOptionValue.ONLINE]]]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'OnlineAttendanceRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected attendance is online.';
+    }
+}

package/dist/src/programmes/rules/TwoYearDurationRule.d.ts

@@ -0,0 +1,6 @@
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export declare class TwoYearDurationRule extends BaseProgrammeFilterKeyValueRule {
+    constructor();
+    getName(): string;
+    getDescription(): string;
+}

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

@@ -0,0 +1,19 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { DurationFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export class TwoYearDurationRule extends BaseProgrammeFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([[
+                FilterKey.DURATION,
+                [DurationFilterOptionValue.TWO_YEARS]
+            ]
+        ]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'TwoYearDurationRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected duration is two years.';
+    }
+}

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

@@ -3,7 +3,6 @@ export class BaseSitemapUrlGeneratorManager {
     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

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

@@ -0,0 +1,3 @@
+export interface IPageNumberProvider {
+    getPageNumber(): number;
+}

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

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

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

@@ -1,6 +1,6 @@
 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 { Area, Attendance, AttendanceDegree, Continent, ContinentTuitionFee, Country, CountryAttendance, Discipline, SpecialProgrammes, TuitionFee, Unfiltered, CountryAttendanceDegree, CountryDuration, CountryDurationDegree, CountryEducationalForm, CountryFormat, CountryTuitionFee, DegreeAttendanceDiscipline, DegreeCountryAttendance, DegreeCountryDiscipline, DegreeCountryTuitionFee, Format, DisciplineAttendance, DisciplineContinent, DisciplineCountry, DisciplineCountryEducationalForm, DisciplineDegree, DisciplineDuration, DisciplineEducationalForm, DisciplineFormat, DisciplineTuitionFee, DisciplineTuitionFeeAttendance, CountryDegree, DegreeFormat, DegreeContinent, DegreeAttendanceTuitionFee, DegreeArea, DegreeTuitionFee, AttendanceTuitionFee, Duration, AttendanceDuration, DegreeAreaTuitionFee, DisciplineContinentAttendance, DegreeContinentTuitionFee, AttendanceFormat, ContinentFormat, AttendanceContinent, DegreeDuration, ContinentSpecialProgrammes, CountrySpecialProgrammes, AttendanceArea, DegreeFormatTuitionFee, ContinentDuration, DegreeAttendanceFormat, DisciplineCountryAttendance, DisciplineCountryFormat, DegreeSpecialProgrammes, Degree, DisciplineSpecialProgrammes, DegreeAttendanceSpecialProgrammes } from '../programmes/policies';
 import { FilterKey } from '@studyportals/search-filters/server-side';
 import { AreaPresenter } from '../presenters/AreaPresenter';
 import { AttendancePresenter } from '../presenters/AttendancePresenter';
@@ -13,7 +13,6 @@ import { SpecialProgrammesPresenter } from '../presenters/SpecialProgrammesPrese
 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;
@@ -30,6 +29,8 @@ export class ProgrammesSitemapUrlGeneratorManager extends BaseSitemapUrlGenerato
             new Area(dependencies),
             new Attendance(dependencies),
             new AttendanceDegree(dependencies),
+            new AttendanceDuration(dependencies),
+            new AttendanceContinent(dependencies),
             new Continent(dependencies),
             new ContinentTuitionFee(dependencies),
             new Country(dependencies),
@@ -39,6 +40,7 @@ export class ProgrammesSitemapUrlGeneratorManager extends BaseSitemapUrlGenerato
             new SpecialProgrammes(dependencies),
             new TuitionFee(dependencies),
             new Unfiltered(dependencies),
+            new Duration(dependencies),
             new CountryAttendanceDegree(dependencies),
             new CountryDegree(dependencies),
             new CountryDuration(dependencies),
@@ -46,11 +48,27 @@ export class ProgrammesSitemapUrlGeneratorManager extends BaseSitemapUrlGenerato
             new CountryEducationalForm(dependencies),
             new CountryFormat(dependencies),
             new CountryTuitionFee(dependencies),
+            new CountrySpecialProgrammes(dependencies),
+            new ContinentFormat(dependencies),
+            new ContinentSpecialProgrammes(dependencies),
+            new ContinentDuration(dependencies),
             new DegreeAttendanceDiscipline(dependencies),
             new DegreeCountryAttendance(dependencies),
             new DegreeCountryDiscipline(dependencies),
             new DegreeCountryTuitionFee(dependencies),
-            new DisciplineArea(dependencies),
+            new DegreeFormat(dependencies),
+            new DegreeContinent(dependencies),
+            new DegreeAttendanceTuitionFee(dependencies),
+            new DegreeArea(dependencies),
+            new DegreeTuitionFee(dependencies),
+            new DegreeAreaTuitionFee(dependencies),
+            new DegreeContinentTuitionFee(dependencies),
+            new DegreeDuration(dependencies),
+            new DegreeFormatTuitionFee(dependencies),
+            new DegreeAttendanceFormat(dependencies),
+            new DegreeSpecialProgrammes(dependencies),
+            new DegreeAttendanceSpecialProgrammes(dependencies),
+            new Format(dependencies),
             new DisciplineAttendance(dependencies),
             new DisciplineContinent(dependencies),
             new DisciplineCountry(dependencies),
@@ -60,7 +78,14 @@ export class ProgrammesSitemapUrlGeneratorManager extends BaseSitemapUrlGenerato
             new DisciplineEducationalForm(dependencies),
             new DisciplineFormat(dependencies),
             new DisciplineTuitionFee(dependencies),
-            new DisciplineTuitionFeeAttendance(dependencies)
+            new DisciplineTuitionFeeAttendance(dependencies),
+            new DisciplineContinentAttendance(dependencies),
+            new DisciplineCountryAttendance(dependencies),
+            new DisciplineCountryFormat(dependencies),
+            new DisciplineSpecialProgrammes(dependencies),
+            new AttendanceTuitionFee(dependencies),
+            new AttendanceFormat(dependencies),
+            new AttendanceArea(dependencies)
         ];
         this.presenters.set(FilterKey.AREA, AreaPresenter.getInstance());
         this.presenters.set(FilterKey.DELIVERY_METHOD, AttendancePresenter.getInstance());

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

@@ -4,10 +4,9 @@ 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[], paywallData?: PaywallDTO): Promise<WithContext<SearchResultsPage>>;
-    protected abstract buildStructuredDataForCard(entity: EntityDTO<TCard>): Promise<Thing | undefined> | Thing | undefined;
+    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.
@@ -26,29 +25,10 @@ export declare abstract class SearchStructuredDataFactory<TCard> {
      * @protected
      */
     protected getOfferData(card: TCard): Promise<OfferDTO | undefined>;
-    /**
-     * Get the paywall data for a card.
-     * This method should be overridden by subclasses to provide the specific paywall logic.
-     * If no paywall data is available, return undefined and no paywall information will be added to the card.
-     *
-     * @param card
-     * @protected
-     */
-    protected getPaywallData(card: TCard): 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;
 }