@studyportals/fawkes 8.0.1-0 → 8.0.1-2

package/dist/src/enums/FilterCombinations.js

@@ -0,0 +1,53 @@
+export var FilterCombinations;
+(function (FilterCombinations) {
+    FilterCombinations["AREA"] = "area";
+    FilterCombinations["AREA_ATTENDANCE"] = "areaAttendance";
+    FilterCombinations["AREA_DISCIPLINE"] = "areaDiscipline";
+    FilterCombinations["COUNTRY"] = "country";
+    FilterCombinations["DEGREE"] = "degree";
+    FilterCombinations["COUNTRY_DEGREE"] = "countryDegree";
+    FilterCombinations["COUNTRY_DURATION"] = "countryDuration";
+    FilterCombinations["COUNTRY_FORMAT"] = "countryFormat";
+    FilterCombinations["COUNTRY_TUITION_FEE"] = "countryTuitionFee";
+    FilterCombinations["COUNTRY_EDUCATIONAL_FORM"] = "countryEducationalForm";
+    FilterCombinations["COUNTRY_ATTENDANCE_DEGREE"] = "countryAttendanceDegree";
+    FilterCombinations["COUNTRY_DURATION_DEGREE"] = "countryDurationDegree";
+    FilterCombinations["DISCIPLINE_AREA"] = "disciplineArea";
+    FilterCombinations["DISCIPLINE_ATTENDANCE"] = "disciplineAttendance";
+    FilterCombinations["DISCIPLINE_COUNTRY"] = "disciplineCountry";
+    FilterCombinations["DISCIPLINE_CONTINENT"] = "disciplineContinent";
+    FilterCombinations["DISCIPLINE_DEGREE"] = "disciplineDegree";
+    FilterCombinations["DISCIPLINE_DURATION"] = "disciplineDuration";
+    FilterCombinations["DISCIPLINE_FORMAT"] = "disciplineFormat";
+    FilterCombinations["DISCIPLINE_TUITION_FEE"] = "disciplineTuitionFee";
+    FilterCombinations["DISCIPLINE_EDUCATIONAL_FORM"] = "disciplineEducationalForm";
+    FilterCombinations["DISCIPLINE_TUITION_FEE_ATTENDANCE"] = "disciplineTuitionFeeAttendance";
+    FilterCombinations["DISCIPLINE_COUNTRY_EDUCATIONAL_FORM"] = "disciplineCountryEducationalForm";
+    FilterCombinations["DEGREE_COUNTRY_DISCIPLINE"] = "degreeCountryDiscipline";
+    FilterCombinations["DEGREE_ATTENDANCE_DISCIPLINE"] = "degreeAttendanceDiscipline";
+    FilterCombinations["DEGREE_COUNTRY_TUITION_FEE"] = "degreeCountryTuitionFee";
+    FilterCombinations["DEGREE_COUNTRY_ATTENDANCE"] = "degreeCountryAttendance";
+    FilterCombinations["DISCIPLINE"] = "discipline";
+    FilterCombinations["UNFILTERED"] = "unfiltered";
+    FilterCombinations["UNIVERSITY_COUNTRY"] = "universityCountry";
+    FilterCombinations["ATTENDANCE_DISCIPLINE"] = "attendancedDiscipline";
+    FilterCombinations["ATTENDANCE_DEGREE"] = "attendanceDegree";
+    FilterCombinations["CONTINENT_ATTENDANCE"] = "continentAttendance";
+    FilterCombinations["COUNTRY_ATTENDANCE"] = "countryAttendance";
+    FilterCombinations["ATTENDANCE"] = "attendance";
+    FilterCombinations["CONTINENT"] = "continent";
+    FilterCombinations["CONTINENT_TUITION_FEE"] = "continentTuitionFee";
+    FilterCombinations["TUITION_FEE"] = "tuitionFee";
+    FilterCombinations["SPECIAL_PROGRAMMES"] = "specialProgrammes";
+    FilterCombinations["RANKED_AREA"] = "rankedArea";
+    FilterCombinations["RANKED_AREA_DISCIPLINE"] = "rankedAreaDiscipline";
+    FilterCombinations["RANKED_ATTENDANCE"] = "rankedAttendance";
+    FilterCombinations["RANKED_ATTENDANCE_DISCIPLINE"] = "rankedAttendancedDiscipline";
+    FilterCombinations["RANKED_CONTINENT"] = "rankedContinent";
+    FilterCombinations["RANKED_CONTINENT_ATTENDANCE"] = "rankedContinentAttendance";
+    FilterCombinations["RANKED_COUNTRY"] = "rankedCountry";
+    FilterCombinations["RANKED_COUNTRY_ATTENDANCE"] = "rankedCountryAttendance";
+    FilterCombinations["RANKED_DISCIPLINE_COUNTRY"] = "rankedDisciplineCountry";
+    FilterCombinations["RANKED_DISCIPLINE"] = "rankedDiscipline";
+    FilterCombinations["RANKED_UNFILTERED"] = "rankedUnfiltered";
+})(FilterCombinations || (FilterCombinations = {}));

package/dist/src/enums/SortingOptions.d.ts

@@ -0,0 +1,4 @@
+export declare enum SortingOptions {
+    OUR_PICKS = "Our picks",
+    UNIVERSITY_META_RANKING = "University Meta Ranking"
+}

package/dist/src/enums/SortingOptions.js

@@ -0,0 +1,5 @@
+export var SortingOptions;
+(function (SortingOptions) {
+    SortingOptions["OUR_PICKS"] = "Our picks";
+    SortingOptions["UNIVERSITY_META_RANKING"] = "University Meta Ranking";
+})(SortingOptions || (SortingOptions = {}));

package/dist/src/errors/DependencyMissingError.d.ts

@@ -0,0 +1,3 @@
+export declare class DependencyMissingError extends Error {
+    constructor(dependencyName: string);
+}

package/dist/src/errors/DependencyMissingError.js

@@ -0,0 +1,5 @@
+export class DependencyMissingError extends Error {
+    constructor(dependencyName) {
+        super(`Dependency ${dependencyName} is missing`);
+    }
+}

package/dist/src/errors/InvalidDependencyTypeError.d.ts

@@ -0,0 +1,3 @@
+export declare class InvalidDependencyTypeError extends Error {
+    constructor();
+}

package/dist/src/errors/InvalidDependencyTypeError.js

@@ -0,0 +1,5 @@
+export class InvalidDependencyTypeError extends Error {
+    constructor() {
+        super('Dependency type is incorrect.');
+    }
+}

package/dist/src/errors/InvalidFilterValueError.d.ts

@@ -0,0 +1,4 @@
+import { FilterKey } from '@studyportals/search-filters';
+export declare class InvalidFilterValueError extends Error {
+    constructor(filterKey: FilterKey, value: string | undefined);
+}

package/dist/src/errors/InvalidFilterValueError.js

@@ -0,0 +1,5 @@
+export class InvalidFilterValueError extends Error {
+    constructor(filterKey, value) {
+        super(`Filter ${filterKey} is missing or has an undefined value. Value: ${value}`);
+    }
+}

package/dist/src/organisations/IOrganisationSearchApplicationState.d.ts

@@ -0,0 +1,5 @@
+import { ISearchApplicationState } from '../common';
+export interface IOrganisationSearchApplicationState extends ISearchApplicationState {
+    getRankedResultsCount(): number;
+    getPageNumber(): number;
+}

package/dist/src/organisations/IOrganisationSearchApplicationState.js

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

package/dist/src/organisations/ISeoSortingState.d.ts

@@ -0,0 +1,4 @@
+import { SortingOptions } from '../enums/SortingOptions';
+export interface ISeoSortingState {
+    getSelectedOption(): SortingOptions;
+}

package/dist/src/organisations/ISeoSortingState.js

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

package/dist/src/organisations/SearchIndexabilityManager.d.ts

@@ -0,0 +1,12 @@
+import { ISearchIndexabilityManager } from '../common/ISearchIndexabilityManager';
+import { ISeoIndexabilityPolicy } from '../common/ISeoIndexabilityPolicy';
+import { IOrganisationSearchApplicationState } from './IOrganisationSearchApplicationState';
+import { ISeoFilterState, ISeoInfoBase } from '../common';
+import { PortalType } from '@studyportals/domain-client';
+import { ISeoSortingState } from '../organisations/ISeoSortingState';
+export declare class SearchIndexabilityManager implements ISearchIndexabilityManager {
+    policies: ISeoIndexabilityPolicy[];
+    constructor(portalType: PortalType, seoInfoBase: ISeoInfoBase, filterState: ISeoFilterState, sortingState: ISeoSortingState, applicationState: IOrganisationSearchApplicationState);
+    shouldIndex(): Promise<boolean>;
+    getPolicies(): ISeoIndexabilityPolicy[];
+}

package/dist/src/organisations/SearchIndexabilityManager.js

@@ -0,0 +1,42 @@
+import { DependencyTypes } from '../enums/DependencyTypes';
+import { Area, AreaAttendance, Attendance, Continent, Country, CountryAttendance, Unfiltered, RankedArea, RankedAreaDiscipline, RankedAttendance, RankedAttendanceDiscipline, RankedContinent, RankedContinentAttendance, RankedCountry, RankedCountryAttendance, RankedCountryDiscipline, RankedDiscipline, RankedUnfiltered } from '../organisations/policies';
+export class SearchIndexabilityManager {
+    policies;
+    constructor(portalType, seoInfoBase, filterState, sortingState, applicationState) {
+        const dependencies = {
+            dependencyType: DependencyTypes.SEARCH,
+            seoInfoBase,
+            filterState,
+            sortingState,
+            applicationState,
+            portalType
+        };
+        this.policies = [
+            new Area(dependencies),
+            new AreaAttendance(dependencies),
+            new Attendance(dependencies),
+            new Continent(dependencies),
+            new Country(dependencies),
+            new CountryAttendance(dependencies),
+            new Unfiltered(dependencies),
+            new RankedArea(dependencies),
+            new RankedAreaDiscipline(dependencies),
+            new RankedAttendance(dependencies),
+            new RankedAttendanceDiscipline(dependencies),
+            new RankedContinent(dependencies),
+            new RankedContinentAttendance(dependencies),
+            new RankedCountry(dependencies),
+            new RankedCountryAttendance(dependencies),
+            new RankedCountryDiscipline(dependencies),
+            new RankedDiscipline(dependencies),
+            new RankedUnfiltered(dependencies)
+        ];
+    }
+    async shouldIndex() {
+        const results = await Promise.all(this.policies.map((policy) => policy.shouldIndex()));
+        return results.some((result) => result);
+    }
+    getPolicies() {
+        return this.policies;
+    }
+}

package/dist/src/organisations/index.d.ts

@@ -0,0 +1,4 @@
+export * from './IOrganisationSearchApplicationState';
+export * from './ISeoSortingState';
+export * from './SearchIndexabilityManager';
+export * from './types';

package/dist/src/organisations/index.js

@@ -0,0 +1,4 @@
+export * from './IOrganisationSearchApplicationState';
+export * from './ISeoSortingState';
+export * from './SearchIndexabilityManager';
+export * from './types';

package/dist/src/organisations/policies/OrganisationsSeoIndexabilityPolicy.d.ts

@@ -0,0 +1,19 @@
+import { PortalType } from '@studyportals/domain-client';
+import { BaseSeoIndexabilityPolicy } from '../../common/policies/BaseSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../types/IOrganisationsSeoDependencies';
+import { SortingOptions } from '../../enums/SortingOptions';
+import { IRule } from '../../common/IRule';
+export declare abstract class OrganisationsSeoIndexabilityPolicy extends BaseSeoIndexabilityPolicy<IOrganisationsSeoDependencies> {
+    protected readonly indexablePortalTypes: PortalType[];
+    protected abstract readonly sortingOption: SortingOptions;
+    protected abstract readonly baseRules: IRule[];
+    private additionalRules;
+    constructor(dependencies: IOrganisationsSeoDependencies);
+    protected get rules(): IRule[];
+    protected addRule(rule: IRule): void;
+    generateSitemapUrls(): Promise<string[]>;
+    protected isIndexable(): Promise<boolean>;
+    protected addResultsCountRule(): void;
+    protected getPathWithSortingOption(path: string): string;
+    private matchesSortingOption;
+}

package/dist/src/organisations/policies/OrganisationsSeoIndexabilityPolicy.js

@@ -0,0 +1,49 @@
+import { PortalType } from '@studyportals/domain-client';
+import { BaseSeoIndexabilityPolicy } from '../../common/policies/BaseSeoIndexabilityPolicy';
+import { IndexablePageNumberRule } from '../../common/rules/IndexablePageNumberRule';
+import { AtLeastSevenResultsRule } from '../../organisations/rules/AtLeastSevenResultsRule';
+export class OrganisationsSeoIndexabilityPolicy extends BaseSeoIndexabilityPolicy {
+    indexablePortalTypes = [PortalType.MASTER];
+    additionalRules = [];
+    constructor(dependencies) {
+        super(dependencies);
+        this.addResultsCountRule();
+    }
+    get rules() {
+        return [...this.baseRules, ...this.additionalRules, new IndexablePageNumberRule()];
+    }
+    addRule(rule) {
+        this.additionalRules.push(rule);
+    }
+    async generateSitemapUrls() {
+        if (this.indexablePortalTypes.includes(this.dependencies.portalType)) {
+            return super.generateSitemapUrls();
+        }
+        return [];
+    }
+    async isIndexable() {
+        const isIndexable = await super.isIndexable();
+        if (!isIndexable) {
+            return false;
+        }
+        return this.indexablePortalTypes.includes(this.dependencies.portalType) && this.matchesSortingOption();
+    }
+    addResultsCountRule() {
+        let resultCountRUle;
+        if (super.isSitemapUrlGeneratorDependencies()) {
+            const dependencies = this.dependencies;
+            resultCountRUle = new AtLeastSevenResultsRule(dependencies.searchApiClient);
+        }
+        else {
+            resultCountRUle = new AtLeastSevenResultsRule();
+        }
+        this.addRule(resultCountRUle);
+    }
+    getPathWithSortingOption(path) {
+        return path;
+    }
+    matchesSortingOption() {
+        const dependencies = this.dependencies;
+        return dependencies.sortingState.getSelectedOption() === this.sortingOption;
+    }
+}

package/dist/src/organisations/policies/RankedOrganisationsSeoIndexabilityPolicy.d.ts

@@ -0,0 +1,9 @@
+import { PortalType } from '@studyportals/domain-client';
+import { SortingOptions } from '../../enums/SortingOptions';
+import { OrganisationsSeoIndexabilityPolicy } from './OrganisationsSeoIndexabilityPolicy';
+export declare abstract class RankedOrganisationsSeoIndexabilityPolicy extends OrganisationsSeoIndexabilityPolicy {
+    protected readonly indexablePortalTypes: PortalType[];
+    protected readonly sortingOption: SortingOptions;
+    protected addResultsCountRule(): void;
+    protected getPathWithSortingOption(path: string): string;
+}

package/dist/src/organisations/policies/RankedOrganisationsSeoIndexabilityPolicy.js

@@ -0,0 +1,22 @@
+import { PortalType } from '@studyportals/domain-client';
+import { SortingOptions } from '../../enums/SortingOptions';
+import { OrganisationsSeoIndexabilityPolicy } from './OrganisationsSeoIndexabilityPolicy';
+import { AtLeastTwoRankedResultsRule } from '../rules/AtLeastTwoRankedResultsRule';
+export class RankedOrganisationsSeoIndexabilityPolicy extends OrganisationsSeoIndexabilityPolicy {
+    indexablePortalTypes = [PortalType.MASTER];
+    sortingOption = SortingOptions.UNIVERSITY_META_RANKING;
+    addResultsCountRule() {
+        let rankedResultsCountRule;
+        if (super.isSitemapUrlGeneratorDependencies()) {
+            const dependencies = this.dependencies;
+            rankedResultsCountRule = new AtLeastTwoRankedResultsRule(dependencies.rankingApiClient);
+        }
+        else {
+            rankedResultsCountRule = new AtLeastTwoRankedResultsRule();
+        }
+        this.addRule(rankedResultsCountRule);
+    }
+    getPathWithSortingOption(path) {
+        return 'rankings/' + path;
+    }
+}

package/dist/src/organisations/policies/index.d.ts

@@ -0,0 +1,18 @@
+export * from './our-picks/Area';
+export * from './our-picks/AreaAttendance';
+export * from './our-picks/Attendance';
+export * from './our-picks/Continent';
+export * from './our-picks/Country';
+export * from './our-picks/CountryAttendance';
+export * from './our-picks/Unfiltered';
+export * from './ranked/RankedArea';
+export * from './ranked/RankedAreaDiscipline';
+export * from './ranked/RankedAttendance';
+export * from './ranked/RankedAttendanceDiscipline';
+export * from './ranked/RankedContinent';
+export * from './ranked/RankedContinentAttendance';
+export * from './ranked/RankedCountry';
+export * from './ranked/RankedCountryAttendance';
+export * from './ranked/RankedCountryDiscipline';
+export * from './ranked/RankedDiscipline';
+export * from './ranked/RankedUnfiltered';

package/dist/src/organisations/policies/index.js

@@ -0,0 +1,18 @@
+export * from './our-picks/Area';
+export * from './our-picks/AreaAttendance';
+export * from './our-picks/Attendance';
+export * from './our-picks/Continent';
+export * from './our-picks/Country';
+export * from './our-picks/CountryAttendance';
+export * from './our-picks/Unfiltered';
+export * from './ranked/RankedArea';
+export * from './ranked/RankedAreaDiscipline';
+export * from './ranked/RankedAttendance';
+export * from './ranked/RankedAttendanceDiscipline';
+export * from './ranked/RankedContinent';
+export * from './ranked/RankedContinentAttendance';
+export * from './ranked/RankedCountry';
+export * from './ranked/RankedCountryAttendance';
+export * from './ranked/RankedCountryDiscipline';
+export * from './ranked/RankedDiscipline';
+export * from './ranked/RankedUnfiltered';

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

@@ -0,0 +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 { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+export declare class Area extends OrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly sortingOption = SortingOptions.OUR_PICKS;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

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

@@ -0,0 +1,35 @@
+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 { AreaPresenter } from '../../../presenters/AreaPresenter';
+export class Area extends OrganisationsSeoIndexabilityPolicy {
+    name = 'Area Policy';
+    description = 'Controls indexing of pages filtered by geographic areas, ensuring only SEO-valuable regional content with sufficient search volume is indexed.';
+    sortingOption = SortingOptions.OUR_PICKS;
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.AREA),
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY])
+    ];
+    async generateUrls() {
+        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;
+    }
+}

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

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

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

@@ -0,0 +1,45 @@
+import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { FilterKey } from '@studyportals/search-filters';
+import { SearchVolumeAreasAttendanceRule } from '../../../organisations/rules/SearchVolumeAreasAttendanceRule';
+import { SortingOptions } from '../../../enums/SortingOptions';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
+import { AreaPresenter } from '../../../presenters/AreaPresenter';
+import { AttendancePresenter } from '../../../presenters/AttendancePresenter';
+export class AreaAttendance extends OrganisationsSeoIndexabilityPolicy {
+    name = 'Area Attendance Policy';
+    description = 'Manages indexability for pages filtered by both geographic area and attendance type, optimizing for region-specific study format combinations.';
+    sortingOption = SortingOptions.OUR_PICKS;
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.AREA),
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY, FilterKey.DELIVERY_METHOD]),
+        new SearchVolumeAreasAttendanceRule(),
+        new OnlineAttendanceRule()
+    ];
+    async generateUrls() {
+        const areaFragments = AreaPresenter.getInstance().getFragments();
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const area of areaFragments) {
+            for (const attendance of attendanceFragments) {
+                const filterKeyValues = new Map([
+                    [FilterKey.AREA, [area.id]],
+                    [FilterKey.COUNTRY, [area.countryId]],
+                    [FilterKey.DELIVERY_METHOD, [attendance.id]]
+                ]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(this.getPathWithSortingOption(`${attendance.path}/${area.path}`));
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.AREA_ATTENDANCE;
+    }
+}

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

@@ -0,0 +1,14 @@
+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 { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
+export declare class Attendance extends OrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly sortingOption = SortingOptions.OUR_PICKS;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule)[];
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

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

@@ -0,0 +1,33 @@
+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 { 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;
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new OnlyFiltersSelectedRule([FilterKey.DELIVERY_METHOD]),
+        new OnlineAttendanceRule()
+    ];
+    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;
+    }
+}

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

@@ -0,0 +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';
+export declare class Continent extends OrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly sortingOption = SortingOptions.OUR_PICKS;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    get filterCombination(): FilterCombinations;
+    protected generateUrls(): Promise<string[]>;
+}

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

@@ -0,0 +1,31 @@
+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 { 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;
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.CONTINENT),
+        new OnlyFiltersSelectedRule([FilterKey.CONTINENT])
+    ];
+    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

@@ -0,0 +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';
+export declare class Country extends OrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly sortingOption = SortingOptions.OUR_PICKS;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    get filterCombination(): FilterCombinations;
+    protected generateUrls(): Promise<string[]>;
+}

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

@@ -0,0 +1,28 @@
+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 { 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;
+    baseRules = [new SingleValueSelectedForFilterRule(FilterKey.COUNTRY), new OnlyFiltersSelectedRule([FilterKey.COUNTRY])];
+    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

@@ -0,0 +1,15 @@
+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 { 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 baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule | SearchVolumeCountriesAttendanceRule)[];
+    get filterCombination(): FilterCombinations;
+    protected generateUrls(): Promise<string[]>;
+}