@studyportals/fawkes 7.2.0 → 7.2.1

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

@@ -0,0 +1,61 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { DegreeAttendanceDisciplineRule } from '../rules/DegreeAttendanceDisciplineRule';
+import { DegreeAttendanceDisciplineSpecificRule } from '../rules/DegreeAttendanceDisciplineSpecificRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { DegreePresenter } from '../../presenters/DegreePresenter';
+import { AttendancePresenter } from '../../presenters/AttendancePresenter';
+import { DisciplinePresenter } from '../../presenters/DisciplinePresenter';
+export class DegreeAttendanceDiscipline extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Degree Attendance Discipline Policy';
+    description = 'Determines indexing rules for pages filtered by degree type, attendance, and discipline.';
+    filterKeys = [FilterKey.DEGREE_TYPE, FilterKey.DELIVERY_METHOD, FilterKey.DISCIPLINES];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new SingleValueSelectedForFilterRule(FilterKey.DISCIPLINES),
+        new OnlyFiltersSelectedRule([FilterKey.DEGREE_TYPE, FilterKey.DELIVERY_METHOD, FilterKey.DISCIPLINES]),
+        new DegreeAttendanceDisciplineSpecificRule(),
+        new DegreeAttendanceDisciplineRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const degreeFragments = DegreePresenter.getInstance().getFragments();
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
+        const paths = [];
+        // Process Master of Science, Master of Arts, and Master of Business Administration degrees with online attendance
+        const allowedDegreeIds = ['master-of-science', 'master-of-arts', 'master-of-business-administration'];
+        const onlineAttendance = attendanceFragments.find(a => a.id === 'online');
+        if (!onlineAttendance) {
+            return paths;
+        }
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const degreeId of allowedDegreeIds) {
+                const degree = degreeFragments.find(d => d.id === degreeId);
+                if (!degree)
+                    continue;
+                for (const discipline of disciplineFragments) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.DEGREE_TYPE, [degree.id]],
+                        [FilterKey.DELIVERY_METHOD, [onlineAttendance.id]],
+                        [FilterKey.DISCIPLINES, [discipline.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${degree.path}/${onlineAttendance.path}/${discipline.path}`, pageNumber));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.DEGREE_ATTENDANCE_DISCIPLINE;
+    }
+}

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

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

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

@@ -0,0 +1,98 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { MBACountryAttendanceRule } from '../rules/MBACountryAttendanceRule';
+import { MasterOfLawsCountryAttendanceRule } from '../rules/MasterOfLawsCountryAttendanceRule';
+import { MasterOfPhilosophyCountryAttendanceRule } from '../rules/MasterOfPhilosophyCountryAttendanceRule';
+import { DegreeCountryAttendanceSpecificRule } from '../rules/DegreeCountryAttendanceSpecificRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { DegreePresenter } from '../../presenters/DegreePresenter';
+import { CountryPresenter } from '../../presenters/CountryPresenter';
+import { AttendancePresenter } from '../../presenters/AttendancePresenter';
+export class DegreeCountryAttendance extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Degree Country Attendance Policy';
+    description = 'Determines indexing rules for pages filtered by degree type, country, and attendance.';
+    filterKeys = [FilterKey.DEGREE_TYPE, FilterKey.COUNTRY, FilterKey.DELIVERY_METHOD];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new OnlyFiltersSelectedRule([FilterKey.DEGREE_TYPE, FilterKey.COUNTRY, FilterKey.DELIVERY_METHOD]),
+        new DegreeCountryAttendanceSpecificRule(),
+        new MBACountryAttendanceRule(),
+        new MasterOfLawsCountryAttendanceRule(),
+        new MasterOfPhilosophyCountryAttendanceRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const degreeFragments = DegreePresenter.getInstance().getFragments();
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const paths = [];
+        // Get degree fragments
+        const mba = degreeFragments.find(d => d.id === 'master-of-business-administration');
+        const llm = degreeFragments.find(d => d.id === 'master-of-laws');
+        const mphil = degreeFragments.find(d => d.id === 'master-of-philosophy');
+        const onlineAttendance = attendanceFragments.find(a => a.id === 'online');
+        if (!onlineAttendance) {
+            return paths;
+        }
+        // Allowed countries for specific degrees
+        const llmAllowedCountryIds = ['82', '30', '32', '108']; // USA, UK, Canada, India
+        const mphilAllowedCountryIds = ['82', '30', '108']; // USA, UK, India
+        for (const pageNumber of this.indexablePageNumbers) {
+            // MBA + online attendance accepts all countries
+            if (mba) {
+                for (const country of countryFragments) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.DEGREE_TYPE, [mba.id]],
+                        [FilterKey.COUNTRY, [country.id]],
+                        [FilterKey.DELIVERY_METHOD, [onlineAttendance.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${mba.path}/${country.path}/${onlineAttendance.path}`, pageNumber));
+                    }
+                }
+            }
+            // Master of Laws + online attendance accepts specific countries
+            if (llm) {
+                const llmCountries = countryFragments.filter(c => llmAllowedCountryIds.includes(c.id));
+                for (const country of llmCountries) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.DEGREE_TYPE, [llm.id]],
+                        [FilterKey.COUNTRY, [country.id]],
+                        [FilterKey.DELIVERY_METHOD, [onlineAttendance.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${llm.path}/${country.path}/${onlineAttendance.path}`, pageNumber));
+                    }
+                }
+            }
+            // Master of Philosophy + online attendance accepts specific countries
+            if (mphil) {
+                const mphilCountries = countryFragments.filter(c => mphilAllowedCountryIds.includes(c.id));
+                for (const country of mphilCountries) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.DEGREE_TYPE, [mphil.id]],
+                        [FilterKey.COUNTRY, [country.id]],
+                        [FilterKey.DELIVERY_METHOD, [onlineAttendance.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${mphil.path}/${country.path}/${onlineAttendance.path}`, pageNumber));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.DEGREE_COUNTRY_ATTENDANCE;
+    }
+}

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

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

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

@@ -0,0 +1,75 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { DegreeCountrySpecificRule } from '../rules/DegreeCountrySpecificRule';
+import { MasterOfEducationCountryDisciplineRule } from '../rules/MasterOfEducationCountryDisciplineRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { DegreePresenter } from '../../presenters/DegreePresenter';
+import { CountryPresenter } from '../../presenters/CountryPresenter';
+import { DisciplinePresenter } from '../../presenters/DisciplinePresenter';
+export class DegreeCountryDiscipline extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Degree Country Discipline Policy';
+    description = 'Determines indexing rules for pages filtered by degree type, country, and discipline with specific degree-country combinations.';
+    filterKeys = [FilterKey.DEGREE_TYPE, FilterKey.COUNTRY, FilterKey.DISCIPLINES];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.DISCIPLINES),
+        new OnlyFiltersSelectedRule([FilterKey.DEGREE_TYPE, FilterKey.COUNTRY, FilterKey.DISCIPLINES]),
+        new DegreeCountrySpecificRule(),
+        new MasterOfEducationCountryDisciplineRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const degreeFragments = DegreePresenter.getInstance().getFragments();
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
+        const paths = [];
+        // Define allowed degrees and their corresponding country IDs
+        const degreeCountryMap = {
+            'master-of-science': ['82', '32', '11', '30'], // USA, Canada, Germany, UK
+            'master-of-business-administration': ['82', '30'], // USA, UK
+            'master-of-education': ['202', '32'] // Australia, Canada
+        };
+        // Education discipline IDs for Master of Education
+        const educationDisciplineIds = [
+            '289', '290', '360', '291', '292', '333', '8', '349',
+            '293', '98', '371', '363', '355', '370', '348', '97',
+            '359', '345', '295', '358'
+        ];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const [degreeId, allowedCountryIds] of Object.entries(degreeCountryMap)) {
+                const degree = degreeFragments.find(d => d.id === degreeId);
+                if (!degree)
+                    continue;
+                const allowedCountries = countryFragments.filter(c => allowedCountryIds.includes(c.id));
+                // Filter disciplines based on degree type
+                let allowedDisciplines = disciplineFragments;
+                if (degreeId === 'master-of-education') {
+                    allowedDisciplines = disciplineFragments.filter(d => educationDisciplineIds.includes(d.id));
+                }
+                for (const country of allowedCountries) {
+                    for (const discipline of allowedDisciplines) {
+                        const filterKeyValues = new Map([
+                            [FilterKey.DEGREE_TYPE, [degree.id]],
+                            [FilterKey.COUNTRY, [country.id]],
+                            [FilterKey.DISCIPLINES, [discipline.id]]
+                        ]);
+                        const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                        if (result) {
+                            paths.push(this.getPathWithPageNumber(`${degree.path}/${country.path}/${discipline.path}`, pageNumber));
+                        }
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.DEGREE_COUNTRY_DISCIPLINE;
+    }
+}

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

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

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

@@ -0,0 +1,81 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { TuitionFeeFilterOptionValue } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { DegreeCountryTuitionFeeRule } from '../rules/DegreeCountryTuitionFeeRule';
+import { MasterOfLawsCountryTuitionFeeRule } from '../rules/MasterOfLawsCountryTuitionFeeRule';
+import { DegreeCountryTuitionFeeSpecificRule } from '../rules/DegreeCountryTuitionFeeSpecificRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { DegreePresenter } from '../../presenters/DegreePresenter';
+import { CountryPresenter } from '../../presenters/CountryPresenter';
+import { TuitionFeePresenter } from '../../presenters/TuitionFeePresenter';
+export class DegreeCountryTuitionFee extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Degree Country Tuition Fee Policy';
+    description = 'Determines indexing rules for pages filtered by degree type, country, and tuition fee.';
+    filterKeys = [FilterKey.DEGREE_TYPE, FilterKey.COUNTRY, FilterKey.TUITION_FEE];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.TUITION_FEE),
+        new OnlyFiltersSelectedRule([FilterKey.DEGREE_TYPE, FilterKey.COUNTRY, FilterKey.TUITION_FEE]),
+        new DegreeCountryTuitionFeeSpecificRule(),
+        new DegreeCountryTuitionFeeRule(),
+        new MasterOfLawsCountryTuitionFeeRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const degreeFragments = DegreePresenter.getInstance().getFragments();
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const tuitionFeeFragments = TuitionFeePresenter.getInstance().getFragments();
+        const paths = [];
+        // Process MBA with affordable tuition fee (all countries)
+        const mba = degreeFragments.find(d => d.id === 'master-of-business-administration');
+        // Process Master of Laws with affordable tuition fee (specific countries)
+        const llm = degreeFragments.find(d => d.id === 'master-of-laws');
+        const affordableTuition = tuitionFeeFragments.find(t => t.id === TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED);
+        if (!affordableTuition) {
+            return paths;
+        }
+        // Allowed countries for Master of Laws
+        const llmAllowedCountryIds = ['82', '30', '32', '108']; // USA, UK, Canada, India
+        for (const pageNumber of this.indexablePageNumbers) {
+            // MBA + affordable tuition accepts all countries
+            if (mba) {
+                for (const country of countryFragments) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.DEGREE_TYPE, [mba.id]],
+                        [FilterKey.COUNTRY, [country.id]],
+                        [FilterKey.TUITION_FEE, [affordableTuition.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${mba.path}/${country.path}/${affordableTuition.path}`, pageNumber));
+                    }
+                }
+            }
+            // Master of Laws + affordable tuition accepts specific countries
+            if (llm) {
+                const llmCountries = countryFragments.filter(c => llmAllowedCountryIds.includes(c.id));
+                for (const country of llmCountries) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.DEGREE_TYPE, [llm.id]],
+                        [FilterKey.COUNTRY, [country.id]],
+                        [FilterKey.TUITION_FEE, [affordableTuition.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${llm.path}/${country.path}/${affordableTuition.path}`, pageNumber));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.DEGREE_COUNTRY_TUITION_FEE;
+    }
+}

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

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

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

@@ -0,0 +1,45 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class DegreeAttendanceDisciplineRule extends BaseProgrammeRule {
+    // Degrees with online attendance that accept all disciplines
+    allowedDegrees = ['master-of-arts', 'master-of-science', 'master-of-business-administration'];
+    attendanceValue = 'online';
+    getName() {
+        return 'DegreeAttendanceDisciplineRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-arts (online) + all disciplines; master-of-science (online) + all disciplines; master-of-business-administration (online) + all disciplines';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const attendanceValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DELIVERY_METHOD, filterState);
+        const disciplineValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DISCIPLINES, filterState);
+        // This rule only applies to allowed degrees + online
+        if (!degreeTypeValue || !attendanceValue || !this.allowedDegrees.includes(degreeTypeValue) || attendanceValue !== this.attendanceValue) {
+            return Promise.resolve(true); // Rule doesn't apply to other combinations
+        }
+        // Must have a discipline selected
+        if (!disciplineValue) {
+            return Promise.resolve(false);
+        }
+        // Allowed degrees + online accept all disciplines
+        return Promise.resolve(true);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const attendanceValues = filterKeyValues.get(FilterKey.DELIVERY_METHOD);
+        const disciplineValues = filterKeyValues.get(FilterKey.DISCIPLINES);
+        if (!degreeTypeValues?.length || !attendanceValues?.length || !disciplineValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const attendanceValue = attendanceValues[0];
+        // This rule only applies to allowed degrees + online
+        if (!degreeTypeValue || !attendanceValue || !this.allowedDegrees.includes(degreeTypeValue) || attendanceValue !== this.attendanceValue) {
+            return Promise.resolve(true); // Rule doesn't apply to other combinations
+        }
+        // Allowed degrees + online accept all disciplines
+        return Promise.resolve(true);
+    }
+}

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

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

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

@@ -0,0 +1,41 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class DegreeAttendanceDisciplineSpecificRule extends BaseProgrammeRule {
+    // Only specific degree types are allowed for this policy
+    allowedDegrees = [
+        'master-of-science',
+        'master-of-arts',
+        'master-of-business-administration'
+    ];
+    // Only online attendance is allowed
+    allowedAttendance = 'online';
+    getName() {
+        return 'DegreeAttendanceDisciplineSpecificRule';
+    }
+    getDescription() {
+        return 'Only allows MSc, MA, and MBA degrees with online attendance for attendance+discipline combinations';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const attendanceValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DELIVERY_METHOD, filterState);
+        if (!degreeTypeValue || !attendanceValue) {
+            return Promise.resolve(false);
+        }
+        // Only allow specific degrees with online attendance
+        return Promise.resolve(this.allowedDegrees.includes(degreeTypeValue) &&
+            attendanceValue === this.allowedAttendance);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const attendanceValues = filterKeyValues.get(FilterKey.DELIVERY_METHOD);
+        if (!degreeTypeValues?.length || !attendanceValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const attendanceValue = attendanceValues[0];
+        // Only allow specific degrees with online attendance
+        return Promise.resolve(this.allowedDegrees.includes(degreeTypeValue) &&
+            attendanceValue === this.allowedAttendance);
+    }
+}

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

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

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

@@ -0,0 +1,42 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class DegreeAttendanceSpecificRule extends BaseProgrammeRule {
+    validCombinations = {
+        'master-of-science': ['online'], // MSc with online attendance
+        'master-of-arts': ['online'], // MA with online attendance
+        'master-of-business-administration': ['online'] // MBA with online attendance
+    };
+    getName() {
+        return 'DegreeAttendanceSpecificRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-science (online); master-of-arts (online); master-of-business-administration (online)';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const attendanceValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DELIVERY_METHOD, filterState);
+        if (!degreeTypeValue || !attendanceValue) {
+            return Promise.resolve(false);
+        }
+        const allowedAttendance = this.validCombinations[degreeTypeValue];
+        if (!allowedAttendance) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(allowedAttendance.includes(attendanceValue));
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const attendanceValues = filterKeyValues.get(FilterKey.DELIVERY_METHOD);
+        if (!degreeTypeValues?.length || !attendanceValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const attendanceValue = attendanceValues[0];
+        const allowedAttendance = this.validCombinations[degreeTypeValue];
+        if (!allowedAttendance) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(allowedAttendance.includes(attendanceValue));
+    }
+}

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

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

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

@@ -0,0 +1,34 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class DegreeCountryAttendanceSpecificRule extends BaseProgrammeRule {
+    // Only specific degree types are allowed for this policy
+    allowedDegrees = [
+        'master-of-business-administration',
+        'master-of-laws',
+        'master-of-philosophy'
+    ];
+    getName() {
+        return 'DegreeCountryAttendanceSpecificRule';
+    }
+    getDescription() {
+        return 'Only allows MBA, LLM, and MPhil degrees for country+attendance combinations';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        if (!degreeTypeValue) {
+            return Promise.resolve(false);
+        }
+        // Only allow specific degrees
+        return Promise.resolve(this.allowedDegrees.includes(degreeTypeValue));
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        if (!degreeTypeValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        // Only allow specific degrees
+        return Promise.resolve(this.allowedDegrees.includes(degreeTypeValue));
+    }
+}

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

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

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

@@ -0,0 +1,42 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class DegreeCountrySpecificRule extends BaseProgrammeRule {
+    validCombinations = {
+        'master-of-science': ['82', '32', '11', '30'], // USA, Canada, Germany, UK
+        'master-of-business-administration': ['82', '30'], // USA, UK
+        'master-of-education': ['202', '32'] // Australia, Canada
+    };
+    getName() {
+        return 'DegreeCountrySpecificRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-science (USA, Canada, Germany, UK); master-of-business-administration (USA, UK); master-of-education (Australia, Canada)';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const countryValue = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        if (!degreeTypeValue || !countryValue) {
+            return Promise.resolve(false);
+        }
+        const allowedCountries = this.validCombinations[degreeTypeValue];
+        if (!allowedCountries) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(allowedCountries.includes(countryValue));
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        if (!degreeTypeValues?.length || !countryValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const countryValue = countryValues[0];
+        const allowedCountries = this.validCombinations[degreeTypeValue];
+        if (!allowedCountries) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(allowedCountries.includes(countryValue));
+    }
+}