@studyportals/fawkes 4.0.3-0 → 5.0.1-1

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

@@ -4,8 +4,11 @@ import { SortingOptions } from '../../../enums/SortingOptions';
 import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-import { OnlineAttendanceRule } from '../../../organisations/rules/OnlineAttendanceRule';
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
+import { AttendancePresenter } from '../../../presenters/AttendancePresenter';
 export class Attendance extends OrganisationsSeoIndexabilityPolicy {
+    name = 'Attendance Policy';
+    description = 'Determines indexing rules for pages filtered by study format (online, on-campus, etc.), prioritizing formats with demonstrated search demand.';
     sortingOption = SortingOptions.OUR_PICKS;
     rules = [
         new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
@@ -13,7 +16,16 @@ export class Attendance extends OrganisationsSeoIndexabilityPolicy {
         new OnlineAttendanceRule()
     ];
     async generateUrls() {
-        throw new Error('Method not implemented.');
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const attendance of attendanceFragments) {
+            const filterKeyValues = new Map([[FilterKey.DELIVERY_METHOD, [attendance.id]]]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(attendance.path));
+            }
+        }
+        return paths;
     }
     get filterCombination() {
         return FilterCombinations.ATTENDANCE;

package/dist/src/organisations/policies/our-picks/Continent.d.ts

@@ -4,8 +4,10 @@ import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/polic
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
 export declare class Continent extends OrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
     protected readonly sortingOption = SortingOptions.OUR_PICKS;
     protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
-    protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;
+    protected generateUrls(): Promise<string[]>;
 }

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

@@ -4,16 +4,28 @@ import { SortingOptions } from '../../../enums/SortingOptions';
 import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { ContinentPresenter } from '../../../presenters/ContinentPresenter';
 export class Continent extends OrganisationsSeoIndexabilityPolicy {
+    name = 'Continent Policy';
+    description = 'Governs indexing of continent-level filtered pages, applying rules to index only continental regions with sufficient search volume and content density.';
     sortingOption = SortingOptions.OUR_PICKS;
     rules = [
         new SingleValueSelectedForFilterRule(FilterKey.CONTINENT),
         new OnlyFiltersSelectedRule([FilterKey.CONTINENT])
     ];
-    async generateUrls() {
-        throw new Error('Method not implemented.');
-    }
     get filterCombination() {
         return FilterCombinations.CONTINENT;
     }
+    async generateUrls() {
+        const continentFragments = ContinentPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const continent of continentFragments) {
+            const filterKeyValues = new Map([[FilterKey.CONTINENT, [continent.id]]]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(continent.path));
+            }
+        }
+        return paths;
+    }
 }

package/dist/src/organisations/policies/our-picks/Country.d.ts

@@ -4,8 +4,10 @@ import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/polic
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
 export declare class Country extends OrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
     protected readonly sortingOption = SortingOptions.OUR_PICKS;
     protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
-    protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;
+    protected generateUrls(): Promise<string[]>;
 }

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

@@ -4,13 +4,25 @@ import { SortingOptions } from '../../../enums/SortingOptions';
 import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { CountryPresenter } from '../../../presenters/CountryPresenter';
 export class Country extends OrganisationsSeoIndexabilityPolicy {
+    name = 'Country Policy';
+    description = 'Manages indexing of country-specific pages, applying rules to index only countries with adequate search demand and relevant content availability.';
     sortingOption = SortingOptions.OUR_PICKS;
     rules = [new SingleValueSelectedForFilterRule(FilterKey.COUNTRY), new OnlyFiltersSelectedRule([FilterKey.COUNTRY])];
-    async generateUrls() {
-        throw new Error('Method not implemented.');
-    }
     get filterCombination() {
         return FilterCombinations.COUNTRY;
     }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const country of countryFragments) {
+            const filterKeyValues = new Map([[FilterKey.COUNTRY, [country.id]]]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(country.path));
+            }
+        }
+        return paths;
+    }
 }

package/dist/src/organisations/policies/our-picks/CountryAttendance.d.ts

@@ -3,11 +3,13 @@ import { SortingOptions } from '../../../enums/SortingOptions';
 import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-import { OnlineAttendanceRule } from '../../../organisations/rules/OnlineAttendanceRule';
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
 import { SearchVolumeCountriesAttendanceRule } from '../../../organisations/rules/SearchVolumeCountriesAttendanceRule';
 export declare class CountryAttendance extends OrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
     protected readonly sortingOption = SortingOptions.OUR_PICKS;
     protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule | SearchVolumeCountriesAttendanceRule)[];
-    protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;
+    protected generateUrls(): Promise<string[]>;
 }

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

@@ -4,9 +4,13 @@ import { SortingOptions } from '../../../enums/SortingOptions';
 import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-import { OnlineAttendanceRule } from '../../../organisations/rules/OnlineAttendanceRule';
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
 import { SearchVolumeCountriesAttendanceRule } from '../../../organisations/rules/SearchVolumeCountriesAttendanceRule';
+import { CountryPresenter } from '../../../presenters/CountryPresenter';
+import { AttendancePresenter } from '../../../presenters/AttendancePresenter';
 export class CountryAttendance extends OrganisationsSeoIndexabilityPolicy {
+    name = 'Country Attendance Policy';
+    description = 'Regulates indexability for pages combining country and attendance type filters, optimizing for country-specific study format pages.';
     sortingOption = SortingOptions.OUR_PICKS;
     rules = [
         new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
@@ -15,10 +19,25 @@ export class CountryAttendance extends OrganisationsSeoIndexabilityPolicy {
         new SearchVolumeCountriesAttendanceRule(),
         new OnlineAttendanceRule()
     ];
-    async generateUrls() {
-        throw new Error('Method not implemented.');
-    }
     get filterCombination() {
         return FilterCombinations.COUNTRY_ATTENDANCE;
     }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const country of countryFragments) {
+            for (const attendance of attendanceFragments) {
+                const filterKeyValues = new Map([
+                    [FilterKey.COUNTRY, [country.id]],
+                    [FilterKey.DELIVERY_METHOD, [attendance.id]]
+                ]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(this.getPathWithSortingOption(`${attendance.path}/${country.path}`));
+                }
+            }
+        }
+        return paths;
+    }
 }

package/dist/src/organisations/policies/our-picks/Unfiltered.d.ts

@@ -3,6 +3,8 @@ import { FilterCombinations } from '../../../enums/FilterCombinations';
 import { SortingOptions } from '../../../enums/SortingOptions';
 import { NoFiltersSelectedRule } from '../../../common/rules/NoFiltersSelectedRule';
 export declare class Unfiltered extends OrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
     protected readonly sortingOption = SortingOptions.OUR_PICKS;
     protected readonly rules: NoFiltersSelectedRule[];
     protected generateUrls(): Promise<string[]>;

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

@@ -3,10 +3,12 @@ import { FilterCombinations } from '../../../enums/FilterCombinations';
 import { SortingOptions } from '../../../enums/SortingOptions';
 import { NoFiltersSelectedRule } from '../../../common/rules/NoFiltersSelectedRule';
 export class Unfiltered extends OrganisationsSeoIndexabilityPolicy {
+    name = 'Unfiltered Policy';
+    description = 'Defines indexability rules for unfiltered pages, managing crawl budget by ensuring only high-value aggregate pages are included in the sitemap.';
     sortingOption = SortingOptions.OUR_PICKS;
     rules = [new NoFiltersSelectedRule()];
-    async generateUrls() {
-        throw new Error('Method not implemented.');
+    generateUrls() {
+        return Promise.resolve([this.getPathWithSortingOption('')]);
     }
     get filterCombination() {
         return FilterCombinations.UNFILTERED;

package/dist/src/organisations/policies/ranked/RankedArea.d.ts

@@ -1,12 +1,13 @@
 import { FilterCombinations } from '../../../enums/FilterCombinations';
-import { SortingOptions } from '../../../enums/SortingOptions';
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
-export declare class RankedArea extends OrganisationsSeoIndexabilityPolicy {
-    protected readonly sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
-    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | AtLeastTwoRankedResultsRule)[];
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedArea extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
     protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;
 }

package/dist/src/organisations/policies/ranked/RankedArea.js

@@ -1,22 +1,37 @@
 import { FilterCombinations } from '../../../enums/FilterCombinations';
 import { FilterKey } from '@studyportals/search-filters';
-import { SortingOptions } from '../../../enums/SortingOptions';
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
-export class RankedArea extends OrganisationsSeoIndexabilityPolicy {
-    sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
+import { AreaPresenter } from '../../../presenters/AreaPresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedArea extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Area Policy';
+    description = 'Controls indexing for ranking-sorted pages filtered by geographic areas, optimizing for region-specific content with quality-based result ordering.';
     rules = [
         new SingleValueSelectedForFilterRule(FilterKey.AREA),
         new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
-        new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY]),
-        new AtLeastTwoRankedResultsRule()
+        new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY])
     ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.addRankedResultsCountRule();
+    }
     async generateUrls() {
-        throw new Error('Method not implemented.');
+        const areaFragments = AreaPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const area of areaFragments) {
+            const filterKeyValues = new Map([
+                [FilterKey.AREA, [area.id]],
+                [FilterKey.COUNTRY, [area.countryId]]
+            ]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(area.path));
+            }
+        }
+        return paths;
     }
     get filterCombination() {
-        return FilterCombinations.AREA;
+        return FilterCombinations.RANKED_AREA;
     }
 }

package/dist/src/organisations/policies/ranked/RankedAreaDiscipline.d.ts

@@ -1,13 +1,14 @@
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SearchVolumeAreasDisciplineRule } from '../../../organisations/rules/SearchVolumeAreasDisciplineRule';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
 import { FilterCombinations } from '../../../enums/FilterCombinations';
-import { SortingOptions } from '../../../enums/SortingOptions';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-export declare class RankedAreaDiscipline extends OrganisationsSeoIndexabilityPolicy {
-    protected readonly sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
-    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | AtLeastTwoRankedResultsRule | SearchVolumeAreasDisciplineRule)[];
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedAreaDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | SearchVolumeAreasDisciplineRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
     get filterCombination(): FilterCombinations;
     protected generateUrls(): Promise<string[]>;
 }

package/dist/src/organisations/policies/ranked/RankedAreaDiscipline.js

@@ -1,25 +1,45 @@
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { SearchVolumeAreasDisciplineRule } from '../../../organisations/rules/SearchVolumeAreasDisciplineRule';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
 import { FilterCombinations } from '../../../enums/FilterCombinations';
 import { FilterKey } from '@studyportals/search-filters';
-import { SortingOptions } from '../../../enums/SortingOptions';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-export class RankedAreaDiscipline extends OrganisationsSeoIndexabilityPolicy {
-    sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
+import { AreaPresenter } from '../../../presenters/AreaPresenter';
+import { DisciplinePresenter } from '../../../presenters/DisciplinePresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedAreaDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Area Discipline Policy';
+    description = 'Controls indexing for ranking-sorted pages filtered by geographic areas, optimizing for region-specific content with quality-based result ordering.';
     rules = [
         new SingleValueSelectedForFilterRule(FilterKey.AREA),
         new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
         new SingleValueSelectedForFilterRule(FilterKey.DISCIPLINES),
         new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY, FilterKey.DISCIPLINES]),
-        new SearchVolumeAreasDisciplineRule(),
-        new AtLeastTwoRankedResultsRule()
+        new SearchVolumeAreasDisciplineRule()
     ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.addRankedResultsCountRule();
+    }
     get filterCombination() {
-        return FilterCombinations.AREA_DISCIPLINE;
+        return FilterCombinations.RANKED_AREA_DISCIPLINE;
     }
-    generateUrls() {
-        throw new Error('Method not implemented.');
+    async generateUrls() {
+        const areaFragments = AreaPresenter.getInstance().getFragments();
+        const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const area of areaFragments) {
+            for (const discipline of disciplineFragments) {
+                const filterKeyValues = new Map([
+                    [FilterKey.AREA, [area.id]],
+                    [FilterKey.COUNTRY, [area.countryId]],
+                    [FilterKey.DISCIPLINES, [discipline.id]]
+                ]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(this.getPathWithSortingOption(`${area.path}/${discipline.path}`));
+                }
+            }
+        }
+        return paths;
     }
 }

package/dist/src/organisations/policies/ranked/RankedAttendance.d.ts

@@ -1,13 +1,14 @@
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
-import { OnlineAttendanceRule } from '../../../organisations/rules/OnlineAttendanceRule';
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
 import { FilterCombinations } from '../../../enums/FilterCombinations';
-import { SortingOptions } from '../../../enums/SortingOptions';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-export declare class RankedAttendance extends OrganisationsSeoIndexabilityPolicy {
-    protected readonly sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
-    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule | AtLeastTwoRankedResultsRule)[];
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedAttendance extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
     protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;
 }

package/dist/src/organisations/policies/ranked/RankedAttendance.js

@@ -1,23 +1,35 @@
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
-import { OnlineAttendanceRule } from '../../../organisations/rules/OnlineAttendanceRule';
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
 import { FilterCombinations } from '../../../enums/FilterCombinations';
 import { FilterKey } from '@studyportals/search-filters';
-import { SortingOptions } from '../../../enums/SortingOptions';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-export class RankedAttendance extends OrganisationsSeoIndexabilityPolicy {
-    sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
+import { AttendancePresenter } from '../../../presenters/AttendancePresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedAttendance extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Attendance Policy';
+    description = 'Determines which ranking-sorted pages filtered by attendance type qualify for indexing based on format-specific search patterns.';
     rules = [
         new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
         new OnlyFiltersSelectedRule([FilterKey.DELIVERY_METHOD]),
-        new AtLeastTwoRankedResultsRule(),
         new OnlineAttendanceRule()
     ];
-    generateUrls() {
-        throw new Error('Method not implemented.');
+    constructor(dependencies) {
+        super(dependencies);
+        this.addRankedResultsCountRule();
+    }
+    async generateUrls() {
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const attendance of attendanceFragments) {
+            const filterKeyValues = new Map([[FilterKey.DELIVERY_METHOD, [attendance.id]]]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(attendance.path));
+            }
+        }
+        return paths;
     }
     get filterCombination() {
-        return FilterCombinations.ATTENDANCE;
+        return FilterCombinations.RANKED_ATTENDANCE;
     }
 }

package/dist/src/organisations/policies/ranked/RankedAttendanceDiscipline.d.ts

@@ -1,13 +1,14 @@
 import { FilterCombinations } from '../../../enums/FilterCombinations';
-import { SortingOptions } from '../../../enums/SortingOptions';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
-import { OnlineAttendanceRule } from '../../../organisations/rules/OnlineAttendanceRule';
-export declare class RankedAttendanceDiscipline extends OrganisationsSeoIndexabilityPolicy {
-    protected readonly sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
-    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule | AtLeastTwoRankedResultsRule)[];
-    protected generateUrls(): Promise<string[]>;
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedAttendanceDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
     get filterCombination(): FilterCombinations;
+    protected generateUrls(): Promise<string[]>;
 }

package/dist/src/organisations/policies/ranked/RankedAttendanceDiscipline.js

@@ -1,24 +1,43 @@
 import { FilterCombinations } from '../../../enums/FilterCombinations';
 import { FilterKey } from '@studyportals/search-filters';
-import { SortingOptions } from '../../../enums/SortingOptions';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
-import { OnlineAttendanceRule } from '../../../organisations/rules/OnlineAttendanceRule';
-export class RankedAttendanceDiscipline extends OrganisationsSeoIndexabilityPolicy {
-    sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
+import { AttendancePresenter } from '../../../presenters/AttendancePresenter';
+import { DisciplinePresenter } from '../../../presenters/DisciplinePresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedAttendanceDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Attendance Discipline Policy';
+    description = 'Manages indexing for ranking-sorted pages at the intersection of attendance type and academic discipline filters.';
     rules = [
         new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
         new SingleValueSelectedForFilterRule(FilterKey.DISCIPLINES),
         new OnlyFiltersSelectedRule([FilterKey.DELIVERY_METHOD, FilterKey.DISCIPLINES]),
-        new AtLeastTwoRankedResultsRule(),
         new OnlineAttendanceRule()
     ];
-    generateUrls() {
-        throw new Error('Method not implemented.');
+    constructor(dependencies) {
+        super(dependencies);
+        this.addRankedResultsCountRule();
     }
     get filterCombination() {
-        return FilterCombinations.ATTENDANCE_DISCIPLINE;
+        return FilterCombinations.RANKED_ATTENDANCE_DISCIPLINE;
+    }
+    async generateUrls() {
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const attendance of attendanceFragments) {
+            for (const discipline of disciplineFragments) {
+                const filterKeyValues = new Map([
+                    [FilterKey.DELIVERY_METHOD, [attendance.id]],
+                    [FilterKey.DISCIPLINES, [discipline.id]]
+                ]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(this.getPathWithSortingOption(`${attendance.path}/${discipline.path}`));
+                }
+            }
+        }
+        return paths;
     }
 }

package/dist/src/organisations/policies/ranked/RankedContinent.d.ts

@@ -1,12 +1,13 @@
 import { FilterCombinations } from '../../../enums/FilterCombinations';
-import { SortingOptions } from '../../../enums/SortingOptions';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-export declare class RankedContinent extends OrganisationsSeoIndexabilityPolicy {
-    protected readonly sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
-    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | AtLeastTwoRankedResultsRule)[];
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedContinent extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
     protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;
 }

package/dist/src/organisations/policies/ranked/RankedContinent.js

@@ -1,21 +1,33 @@
 import { FilterCombinations } from '../../../enums/FilterCombinations';
 import { FilterKey } from '@studyportals/search-filters';
-import { SortingOptions } from '../../../enums/SortingOptions';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-export class RankedContinent extends OrganisationsSeoIndexabilityPolicy {
-    sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
+import { ContinentPresenter } from '../../../presenters/ContinentPresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedContinent extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Continent Policy';
+    description = 'Regulates indexability of ranking-sorted continent-level filtered pages, prioritizing high-value continental views with quality-based sorting.';
     rules = [
         new SingleValueSelectedForFilterRule(FilterKey.CONTINENT),
-        new OnlyFiltersSelectedRule([FilterKey.CONTINENT]),
-        new AtLeastTwoRankedResultsRule()
+        new OnlyFiltersSelectedRule([FilterKey.CONTINENT])
     ];
-    generateUrls() {
-        throw new Error('Method not implemented.');
+    constructor(dependencies) {
+        super(dependencies);
+        this.addRankedResultsCountRule();
+    }
+    async generateUrls() {
+        const continentFragments = ContinentPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const continent of continentFragments) {
+            const filterKeyValues = new Map([[FilterKey.CONTINENT, [continent.id]]]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(continent.path));
+            }
+        }
+        return paths;
     }
     get filterCombination() {
-        return FilterCombinations.CONTINENT;
+        return FilterCombinations.RANKED_CONTINENT;
     }
 }

package/dist/src/organisations/policies/ranked/RankedContinentAttendance.d.ts

@@ -1,14 +1,15 @@
 import { FilterCombinations } from '../../../enums/FilterCombinations';
-import { SortingOptions } from '../../../enums/SortingOptions';
 import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
-import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
 import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
-import { OnlineAttendanceRule } from '../../../organisations/rules/OnlineAttendanceRule';
-import { AtLeastTwoRankedResultsRule } from '../../../organisations/rules/AtLeastTwoRankedResultsRule';
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
 import { ContinentIsEuropeRule } from '../../../organisations/rules/ContinentIsEuropeRule';
-export declare class RankedContinentAttendance extends OrganisationsSeoIndexabilityPolicy {
-    protected readonly sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
-    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule | AtLeastTwoRankedResultsRule | ContinentIsEuropeRule)[];
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedContinentAttendance extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule | ContinentIsEuropeRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
     protected generateUrls(): Promise<string[]>;
     get filterCombination(): FilterCombinations;
 }