@studyportals/fawkes 2.0.1-20 → 2.0.1-21

package/dist/src/scholarships/policies/CountryPolicy.d.ts

@@ -1,8 +1,12 @@
-import { BaseSeoIndexabilityPolicy } from '@/common/BaseSeoIndexabilityPolicy';
-import { ISeoFilterState } from '@/common/ISeoFilterState';
-import { ISeoInfoBase } from '@/common/ISeoInfoBase';
-export declare class CountryPolicy extends BaseSeoIndexabilityPolicy {
-    constructor(seoInfoBase: ISeoInfoBase, filterState: ISeoFilterState);
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ICustomRule } from '../../common/ICustomRule';
+import { SeoDependencies } from '../../types/SeoDependencies';
+import { RuleBasedIndexabilityPolicy } from '../../common/RuleBasedIndexabilityPolicy';
+import { ISeoIndexabilityPolicy } from '../../common/ISeoIndexabilityPolicy';
+export declare class CountryPolicy extends RuleBasedIndexabilityPolicy implements ISeoIndexabilityPolicy {
+    protected rules: ICustomRule[];
+    constructor(dependencies: SeoDependencies);
     protected matchesFilters(): Promise<boolean>;
-    generatePaths(): string[];
+    generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
 }

package/dist/src/scholarships/policies/CountryPolicy.js

@@ -1,17 +1,39 @@
 import { FilterKey } from '@studyportals/search-filters';
-import { BaseSeoIndexabilityPolicy } from '@/common/BaseSeoIndexabilityPolicy';
-export class CountryPolicy extends BaseSeoIndexabilityPolicy {
-    constructor(seoInfoBase, filterState) {
-        super(seoInfoBase, filterState);
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { SearchVolumeCountriesRule } from '../rules/SearchVolumeCountriesRule';
+import { RuleBasedIndexabilityPolicy } from '../../common/RuleBasedIndexabilityPolicy';
+import { CountryPresenter } from '../../presenters/CountryPresenter';
+export class CountryPolicy extends RuleBasedIndexabilityPolicy {
+    rules = [
+        SearchVolumeCountriesRule.getInstance()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
     }
     async matchesFilters() {
-        const singleCountrySelected = await this.seoInfoBase.singleSelectionFor(FilterKey.COUNTRY, this.filterState);
-        const onlyCountrySelected = await this.seoInfoBase.selectionOnlyFor([
+        const { seoInfoBase, filterState } = this.dependencies;
+        const singleCountrySelected = await seoInfoBase.singleSelectionFor(FilterKey.COUNTRY, filterState);
+        const onlyCountrySelected = await seoInfoBase.selectionOnlyFor([
             FilterKey.COUNTRY
-        ], this.filterState);
-        return singleCountrySelected && onlyCountrySelected;
+        ], filterState);
+        const countrySelected = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        const hasSearchVolume = this.checksEveryRuleForSearch({
+            [FilterKey.COUNTRY]: countrySelected ?? undefined
+        });
+        return singleCountrySelected
+            && onlyCountrySelected
+            && hasSearchVolume;
     }
-    generatePaths() {
-        throw new Error('Method not implemented.');
+    generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const paths = countryFragments
+            .filter(country => this.checksEveryRuleForSitemap({
+            [FilterKey.COUNTRY]: country.id
+        }))
+            .map(country => country.path);
+        return Promise.resolve(paths);
+    }
+    get filterCombination() {
+        return FilterCombinations.COUNTRY;
     }
 }

package/dist/src/scholarships/policies/DisciplineCountryPolicy.d.ts

@@ -1,11 +1,12 @@
-import { BaseSeoIndexabilityPolicy } from '@/common/BaseSeoIndexabilityPolicy';
-import { ISeoSearchApplicationState } from '@/common/ISeoSearchApplicationState';
-import { ISeoFilterState } from '@/common/ISeoFilterState';
-import { ISeoInfoBase } from '@/common/ISeoInfoBase';
-import { ISeoIndexabilityPolicy } from '@/common/ISeoIndexabilityPolicy';
-export declare class DisciplineCountryPolicy extends BaseSeoIndexabilityPolicy implements ISeoIndexabilityPolicy {
-    private applicationState;
-    constructor(seoInfoBase: ISeoInfoBase, filterState: ISeoFilterState, applicationState: ISeoSearchApplicationState);
+import { ISeoIndexabilityPolicy } from '../../common/ISeoIndexabilityPolicy';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { SeoDependencies } from '../../types/SeoDependencies';
+import { RuleBasedIndexabilityPolicy } from '../../common/RuleBasedIndexabilityPolicy';
+import { ICustomRule } from '../../common/ICustomRule';
+export declare class DisciplineCountryPolicy extends RuleBasedIndexabilityPolicy implements ISeoIndexabilityPolicy {
+    protected rules: ICustomRule[];
+    constructor(dependencies: SeoDependencies);
     protected matchesFilters(): Promise<boolean>;
-    generatePaths(): string[];
+    generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
 }

package/dist/src/scholarships/policies/DisciplineCountryPolicy.js

@@ -1,26 +1,54 @@
 import { FilterKey } from '@studyportals/search-filters';
-import { BaseSeoIndexabilityPolicy } from '@/common/BaseSeoIndexabilityPolicy';
-import { CustomRules } from '../CustomRules';
-export class DisciplineCountryPolicy extends BaseSeoIndexabilityPolicy {
-    applicationState;
-    constructor(seoInfoBase, filterState, applicationState) {
-        super(seoInfoBase, filterState);
-        this.applicationState = applicationState;
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { RuleBasedIndexabilityPolicy } from '../../common/RuleBasedIndexabilityPolicy';
+import { SearchVolumeCountriesDisciplinesRule } from '../rules/SearchVolumeCountryDisciplineRule';
+import { CountryPresenter } from '../../presenters/CountryPresenter';
+export class DisciplineCountryPolicy extends RuleBasedIndexabilityPolicy {
+    rules = [
+        SearchVolumeCountriesDisciplinesRule.getInstance()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
     }
     async matchesFilters() {
-        const singleDisciplineSelected = await this.seoInfoBase.singleSelectionFor(FilterKey.DISCIPLINES, this.filterState);
-        const singleCountrySelected = await this.seoInfoBase.singleSelectionFor(FilterKey.COUNTRY, this.filterState);
-        const onlyDisciplineAndCountrySelected = await this.seoInfoBase.selectionOnlyFor([
+        const { seoInfoBase, filterState, applicationState } = this.dependencies;
+        if (!applicationState) {
+            throw new Error('Application State dependencies are missing.');
+        }
+        const singleDisciplineSelected = await seoInfoBase.singleSelectionFor(FilterKey.DISCIPLINES, filterState);
+        const singleCountrySelected = await seoInfoBase.singleSelectionFor(FilterKey.COUNTRY, filterState);
+        const onlyDisciplineAndCountrySelected = await seoInfoBase.selectionOnlyFor([
             FilterKey.DISCIPLINES,
             FilterKey.COUNTRY
-        ], this.filterState);
-        const hasEnoughResults = CustomRules.hasMoreThan31Results(this.applicationState);
+        ], filterState);
+        const countrySelected = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        const disciplineSelected = seoInfoBase.getFilterOptionValueBy(FilterKey.DISCIPLINES, filterState);
+        const hasSearchVolume = this.checksEveryRuleForSearch({
+            [FilterKey.COUNTRY]: countrySelected ?? undefined,
+            [FilterKey.DISCIPLINES]: disciplineSelected ?? undefined
+        });
         return singleDisciplineSelected
             && singleCountrySelected
             && onlyDisciplineAndCountrySelected
-            && hasEnoughResults;
+            && hasSearchVolume;
     }
-    generatePaths() {
-        throw new Error('Method not implemented.');
+    generateUrls() {
+        const paths = [];
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const disciplineFragments = CountryPresenter.getInstance().getFragments();
+        countryFragments.forEach(country => {
+            disciplineFragments.forEach(discipline => {
+                if (this.checksEveryRuleForSitemap({
+                    [FilterKey.COUNTRY]: country.id,
+                    [FilterKey.DISCIPLINES]: discipline.id
+                })) {
+                    paths.push(`${country.path}/${discipline.path}`);
+                }
+            });
+        });
+        return Promise.resolve(paths);
+    }
+    get filterCombination() {
+        return FilterCombinations.DISCIPLINE_COUNTRY;
     }
 }

package/dist/src/scholarships/policies/DisciplinePolicy.d.ts

@@ -1,8 +1,12 @@
-import { BaseSeoIndexabilityPolicy } from '@/common/BaseSeoIndexabilityPolicy';
-import { ISeoFilterState } from '@/common/ISeoFilterState';
-import { ISeoInfoBase } from '@/common/ISeoInfoBase';
-export declare class DisciplinePolicy extends BaseSeoIndexabilityPolicy {
-    constructor(seoInfoBase: ISeoInfoBase, filterState: ISeoFilterState);
+import { SeoDependencies } from '../../types/SeoDependencies';
+import { ICustomRule } from '../../common/ICustomRule';
+import { ISeoIndexabilityPolicy } from '../../common/ISeoIndexabilityPolicy';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { RuleBasedIndexabilityPolicy } from '../../common/RuleBasedIndexabilityPolicy';
+export declare class DisciplinePolicy extends RuleBasedIndexabilityPolicy implements ISeoIndexabilityPolicy {
+    protected rules: ICustomRule[];
+    constructor(dependencies: SeoDependencies);
     protected matchesFilters(): Promise<boolean>;
-    generatePaths(): string[];
+    generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
 }

package/dist/src/scholarships/policies/DisciplinePolicy.js

@@ -1,17 +1,40 @@
 import { FilterKey } from '@studyportals/search-filters';
-import { BaseSeoIndexabilityPolicy } from '@/common/BaseSeoIndexabilityPolicy';
-export class DisciplinePolicy extends BaseSeoIndexabilityPolicy {
-    constructor(seoInfoBase, filterState) {
-        super(seoInfoBase, filterState);
+import { DisciplinePresenter } from '../../presenters/DisciplinePresenter';
+import { SearchVolumeDisciplinesRule } from '../../scholarships/rules/SearchVolumeDisciplinesRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { RuleBasedIndexabilityPolicy } from '../../common/RuleBasedIndexabilityPolicy';
+export class DisciplinePolicy extends RuleBasedIndexabilityPolicy {
+    rules;
+    constructor(dependencies) {
+        super(dependencies);
+        this.rules = [
+            SearchVolumeDisciplinesRule.getInstance(),
+        ];
     }
     async matchesFilters() {
-        const singleDisciplineSelected = await this.seoInfoBase.singleSelectionFor(FilterKey.DISCIPLINES, this.filterState);
-        const onlyDisciplineSelected = await this.seoInfoBase.selectionOnlyFor([
+        const { seoInfoBase, filterState } = this.dependencies;
+        const singleDisciplineSelected = await seoInfoBase.singleSelectionFor(FilterKey.DISCIPLINES, filterState);
+        const onlyDisciplineSelected = await seoInfoBase.selectionOnlyFor([
             FilterKey.DISCIPLINES
-        ], this.filterState);
-        return singleDisciplineSelected && onlyDisciplineSelected;
+        ], filterState);
+        const disciplineSelected = seoInfoBase.getFilterOptionValueBy(FilterKey.DISCIPLINES, filterState);
+        const hasSearchVolume = this.checksEveryRuleForSearch({
+            [FilterKey.DISCIPLINES]: disciplineSelected ?? undefined
+        });
+        return singleDisciplineSelected
+            && onlyDisciplineSelected
+            && hasSearchVolume;
     }
-    generatePaths() {
-        throw new Error('Method not implemented.');
+    generateUrls() {
+        const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
+        const paths = disciplineFragments
+            .filter(discipline => this.checksEveryRuleForSitemap({
+            [FilterKey.DISCIPLINES]: discipline.id
+        }))
+            .map(discipline => discipline.path);
+        return Promise.resolve(paths);
+    }
+    get filterCombination() {
+        return FilterCombinations.DISCIPLINE;
     }
 }

package/dist/src/scholarships/policies/UnfilteredPolicy.d.ts

@@ -1,8 +1,9 @@
-import { ISeoInfoBase } from '@/common/ISeoInfoBase';
-import { ISeoFilterState } from '@/common/ISeoFilterState';
-import { BaseSeoIndexabilityPolicy } from '@/common/BaseSeoIndexabilityPolicy';
+import { BaseSeoIndexabilityPolicy } from '../../common/BaseSeoIndexabilityPolicy';
+import { SeoDependencies } from '../../types/SeoDependencies';
+import { FilterCombinations } from '../../enums/FilterCombinations';
 export declare class UnfilteredPolicy extends BaseSeoIndexabilityPolicy {
-    constructor(seoInfoBase: ISeoInfoBase, filterState: ISeoFilterState);
+    constructor(dependencies: SeoDependencies);
     protected matchesFilters(): Promise<boolean>;
-    generatePaths(): string[];
+    generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
 }

package/dist/src/scholarships/policies/UnfilteredPolicy.js

@@ -1,12 +1,17 @@
-import { BaseSeoIndexabilityPolicy } from '@/common/BaseSeoIndexabilityPolicy';
+import { BaseSeoIndexabilityPolicy } from '../../common/BaseSeoIndexabilityPolicy';
+import { FilterCombinations } from '../../enums/FilterCombinations';
 export class UnfilteredPolicy extends BaseSeoIndexabilityPolicy {
-    constructor(seoInfoBase, filterState) {
-        super(seoInfoBase, filterState);
+    constructor(dependencies) {
+        super(dependencies);
     }
     async matchesFilters() {
-        return Promise.resolve(this.seoInfoBase.getSelectionTypeCount(this.filterState) === 0);
+        const { seoInfoBase, filterState } = this.dependencies;
+        return Promise.resolve(seoInfoBase.getSelectionTypeCount(filterState) === 0);
     }
-    generatePaths() {
-        throw new Error('Method not implemented.');
+    generateUrls() {
+        return Promise.resolve(['/']);
+    }
+    get filterCombination() {
+        return FilterCombinations.UNFILTERED;
     }
 }

package/dist/src/scholarships/policies/UniversityCountryPolicy.d.ts

@@ -1,8 +1,9 @@
-import { BaseSeoIndexabilityPolicy } from '@/common/BaseSeoIndexabilityPolicy';
-import { ISeoFilterState } from '@/common/ISeoFilterState';
-import { ISeoInfoBase } from '@/common/ISeoInfoBase';
+import { BaseSeoIndexabilityPolicy } from '../../common/BaseSeoIndexabilityPolicy';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { SeoDependencies } from '../../types/SeoDependencies';
 export declare class UniversityCountryPolicy extends BaseSeoIndexabilityPolicy {
-    constructor(seoInfoBase: ISeoInfoBase, filterState: ISeoFilterState);
+    constructor(dependencies: SeoDependencies);
     protected matchesFilters(): Promise<boolean>;
-    generatePaths(): string[];
+    generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
 }

package/dist/src/scholarships/policies/UniversityCountryPolicy.js

@@ -1,21 +1,47 @@
 import { FilterKey } from '@studyportals/search-filters';
-import { BaseSeoIndexabilityPolicy } from '@/common/BaseSeoIndexabilityPolicy';
+import { BaseSeoIndexabilityPolicy } from '../../common/BaseSeoIndexabilityPolicy';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { CountryPresenter } from '../../presenters/CountryPresenter';
 export class UniversityCountryPolicy extends BaseSeoIndexabilityPolicy {
-    constructor(seoInfoBase, filterState) {
-        super(seoInfoBase, filterState);
+    constructor(dependencies) {
+        super(dependencies);
     }
     async matchesFilters() {
-        const singleUniversitySelected = await this.seoInfoBase.singleSelectionFor(FilterKey.ORGANISATIONS, this.filterState);
-        const singleCountrySelected = await this.seoInfoBase.singleSelectionFor(FilterKey.COUNTRY, this.filterState);
-        const onlyUniversityAndDisciplineSelected = await this.seoInfoBase.selectionOnlyFor([
+        const { seoInfoBase, filterState } = this.dependencies;
+        const singleUniversitySelected = await seoInfoBase.singleSelectionFor(FilterKey.ORGANISATIONS, filterState);
+        const singleCountrySelected = await seoInfoBase.singleSelectionFor(FilterKey.COUNTRY, filterState);
+        const onlyUniversityAndDisciplineSelected = await seoInfoBase.selectionOnlyFor([
             FilterKey.ORGANISATIONS,
             FilterKey.COUNTRY
-        ], this.filterState);
+        ], filterState);
         return singleUniversitySelected
             && singleCountrySelected
             && onlyUniversityAndDisciplineSelected;
     }
-    generatePaths() {
-        throw new Error('Method not implemented.');
+    async generateUrls() {
+        const { searchApiClient, organisationsClient } = this.dependencies;
+        if (!searchApiClient || !organisationsClient) {
+            throw new Error('Search API Client or Organisation Client dependencies are missing.');
+        }
+        const organisationIds = await searchApiClient.getOrganisationIds();
+        const organisations = await organisationsClient.getOrganisations(organisationIds);
+        const isoToPath = new Map();
+        const countries = CountryPresenter.getInstance().getFragments();
+        countries.forEach(country => {
+            isoToPath.set(country.id, country.path);
+        });
+        const paths = [];
+        organisations.forEach(org => {
+            org.countryIsoCodes.forEach(iso => {
+                const countryVirtualPath = isoToPath.get(iso);
+                if (countryVirtualPath) {
+                    paths.push(`/${countryVirtualPath}/${org.virtualPath}`);
+                }
+            });
+        });
+        return Promise.resolve(paths);
+    }
+    get filterCombination() {
+        return FilterCombinations.UNIVERSITY_COUNTRY;
     }
 }

package/dist/src/scholarships/rules/ExceptAustaliaAreasRule.d.ts

@@ -0,0 +1,14 @@
+import { ICustomRule } from "../../common/ICustomRule";
+import { IFilterKeyValues } from "../../common/IFilterKeyValues";
+export declare class ExceptAustraliaAreasRule implements ICustomRule {
+    private areasPresenter;
+    private static instance;
+    private australiaCountryId;
+    private constructor();
+    static getInstance(): ExceptAustraliaAreasRule;
+    forSearch(filterSet: IFilterKeyValues): boolean;
+    forSitemapGenerator(filterKeyValues: IFilterKeyValues): boolean;
+    getName(): string;
+    private isNotAustralia;
+    private doesNotBelongToAustralia;
+}

package/dist/src/scholarships/rules/ExceptAustaliaAreasRule.js

@@ -0,0 +1,45 @@
+import { AreaPresenter } from "../../presenters/AreaPresenter";
+import { FilterKey } from "@studyportals/search-filters";
+export class ExceptAustraliaAreasRule {
+    areasPresenter;
+    static instance;
+    australiaCountryId = 202;
+    constructor() {
+        this.areasPresenter = AreaPresenter.getInstance();
+    }
+    static getInstance() {
+        if (!ExceptAustraliaAreasRule.instance) {
+            ExceptAustraliaAreasRule.instance = new ExceptAustraliaAreasRule();
+        }
+        return ExceptAustraliaAreasRule.instance;
+    }
+    forSearch(filterSet) {
+        const value = filterSet[FilterKey.AREA];
+        if (!value) {
+            return false;
+        }
+        return this.doesNotBelongToAustralia(value);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const value = filterKeyValues[FilterKey.COUNTRY];
+        if (!value) {
+            throw new Error(`Invalid filter provided or undefined value.`);
+        }
+        return this.isNotAustralia(value);
+    }
+    getName() {
+        return 'ExceptAustraliaAreasRule';
+    }
+    isNotAustralia(countryId) {
+        return countryId !== this.australiaCountryId.toString();
+    }
+    doesNotBelongToAustralia(filterId) {
+        const areas = this.areasPresenter.getFragments();
+        const foundArea = areas.find((area) => area.id === filterId);
+        // TODO: This condition is not correct, decide what to do
+        if (!foundArea) {
+            return false;
+        }
+        return foundArea.countryId !== this.australiaCountryId.toString();
+    }
+}

package/dist/src/scholarships/rules/SearchVolumeAreasRule.d.ts

@@ -0,0 +1,12 @@
+import { ICustomRule } from "../../common/ICustomRule";
+import { IFilterKeyValues } from "../../common/IFilterKeyValues";
+export declare class SearchVolumeAreasRule implements ICustomRule {
+    private static instance;
+    private areasWithNoSearchVolume;
+    private constructor();
+    static getInstance(): SearchVolumeAreasRule;
+    forSearch(filterSet: IFilterKeyValues): boolean;
+    forSitemapGenerator(filterSet: IFilterKeyValues): boolean;
+    getName(): string;
+    private hasSearchVolume;
+}

package/dist/src/scholarships/rules/SearchVolumeAreasRule.js

@@ -0,0 +1,34 @@
+import { FilterKey } from "@studyportals/search-filters";
+export class SearchVolumeAreasRule {
+    static instance;
+    areasWithNoSearchVolume;
+    constructor() {
+        this.areasWithNoSearchVolume = [3579, 995];
+    }
+    static getInstance() {
+        if (!SearchVolumeAreasRule.instance) {
+            SearchVolumeAreasRule.instance = new SearchVolumeAreasRule();
+        }
+        return SearchVolumeAreasRule.instance;
+    }
+    forSearch(filterSet) {
+        const value = filterSet[FilterKey.AREA];
+        if (!value) {
+            return false;
+        }
+        return this.hasSearchVolume(value);
+    }
+    forSitemapGenerator(filterSet) {
+        const value = filterSet[FilterKey.AREA];
+        if (!value) {
+            throw new Error(`Invalid filter provided or undefined value.`);
+        }
+        return this.hasSearchVolume(value);
+    }
+    getName() {
+        return 'SearchVolumeAreasRule';
+    }
+    hasSearchVolume(areaId) {
+        return !this.areasWithNoSearchVolume.includes(Number(areaId));
+    }
+}

package/dist/src/scholarships/rules/SearchVolumeCountriesRule.d.ts

@@ -0,0 +1,12 @@
+import { ICustomRule } from "../../common/ICustomRule";
+import { IFilterKeyValues } from "../../common/IFilterKeyValues";
+export declare class SearchVolumeCountriesRule implements ICustomRule {
+    private static instance;
+    private countriesWithNoSearchVolume;
+    private constructor();
+    static getInstance(): SearchVolumeCountriesRule;
+    forSearch(filterSet: IFilterKeyValues): boolean;
+    forSitemapGenerator(filterSet: IFilterKeyValues): boolean;
+    getName(): string;
+    private hasSearchVolume;
+}

package/dist/src/scholarships/rules/SearchVolumeCountriesRule.js

@@ -0,0 +1,34 @@
+import { FilterKey } from "@studyportals/search-filters";
+export class SearchVolumeCountriesRule {
+    static instance;
+    countriesWithNoSearchVolume;
+    constructor() {
+        this.countriesWithNoSearchVolume = [122, 107, 18];
+    }
+    static getInstance() {
+        if (!SearchVolumeCountriesRule.instance) {
+            SearchVolumeCountriesRule.instance = new SearchVolumeCountriesRule();
+        }
+        return SearchVolumeCountriesRule.instance;
+    }
+    forSearch(filterSet) {
+        const value = filterSet[FilterKey.COUNTRY];
+        if (!value) {
+            return false;
+        }
+        return this.hasSearchVolume(value);
+    }
+    forSitemapGenerator(filterSet) {
+        const value = filterSet[FilterKey.COUNTRY];
+        if (!value) {
+            return false;
+        }
+        return this.hasSearchVolume(value);
+    }
+    getName() {
+        return 'SearchVolumeCountriesRule';
+    }
+    hasSearchVolume(countryId) {
+        return !this.countriesWithNoSearchVolume.includes(Number(countryId));
+    }
+}

package/dist/src/scholarships/rules/SearchVolumeCountryDisciplineRule.d.ts

@@ -0,0 +1,12 @@
+import { ICustomRule } from "../../common/ICustomRule";
+import { IFilterKeyValues } from "../../common/IFilterKeyValues";
+export declare class SearchVolumeCountriesDisciplinesRule implements ICustomRule {
+    private static instance;
+    private combinationsWithSearchVolume;
+    private constructor();
+    static getInstance(): SearchVolumeCountriesDisciplinesRule;
+    forSearch(filterSet: IFilterKeyValues): boolean;
+    forSitemapGenerator(filterSet: IFilterKeyValues): boolean;
+    getName(): string;
+    private hasSearchVolume;
+}

package/dist/src/scholarships/rules/SearchVolumeCountryDisciplineRule.js

@@ -0,0 +1,37 @@
+import searchVolume from './files/search-volume.json';
+import { FilterKey } from "@studyportals/search-filters";
+export class SearchVolumeCountriesDisciplinesRule {
+    static instance;
+    combinationsWithSearchVolume;
+    constructor() {
+        this.combinationsWithSearchVolume = new Set(searchVolume.map(({ ci, di }) => `${ci},${di}`));
+    }
+    static getInstance() {
+        if (!SearchVolumeCountriesDisciplinesRule.instance) {
+            SearchVolumeCountriesDisciplinesRule.instance = new SearchVolumeCountriesDisciplinesRule();
+        }
+        return SearchVolumeCountriesDisciplinesRule.instance;
+    }
+    forSearch(filterSet) {
+        const countryValue = filterSet[FilterKey.COUNTRY];
+        const disciplineValue = filterSet[FilterKey.DISCIPLINES];
+        if (!countryValue || !disciplineValue) {
+            return false;
+        }
+        return this.hasSearchVolume(countryValue, disciplineValue);
+    }
+    forSitemapGenerator(filterSet) {
+        const countryValue = filterSet[FilterKey.COUNTRY];
+        const disciplineValue = filterSet[FilterKey.DISCIPLINES];
+        if (!countryValue || !disciplineValue) {
+            throw new Error(`SitemapGenerator: Invalid filter provided or undefined value.`);
+        }
+        return this.hasSearchVolume(countryValue, disciplineValue);
+    }
+    getName() {
+        return 'SearchVolumeCountriesDisciplinesRule';
+    }
+    hasSearchVolume(countryId, disciplineId) {
+        return this.combinationsWithSearchVolume.has(`${countryId},${disciplineId}`);
+    }
+}

package/dist/src/scholarships/rules/SearchVolumeDisciplinesRule.d.ts

@@ -0,0 +1,12 @@
+import { ICustomRule } from "../../common/ICustomRule";
+import { IFilterKeyValues } from "../../common/IFilterKeyValues";
+export declare class SearchVolumeDisciplinesRule implements ICustomRule {
+    private static instance;
+    private disciplinesWithNoSearchVolume;
+    private constructor();
+    static getInstance(): SearchVolumeDisciplinesRule;
+    forSearch(filterSet: IFilterKeyValues): boolean;
+    forSitemapGenerator(filterSet: IFilterKeyValues): boolean;
+    getName(): string;
+    private hasSearchVolume;
+}

package/dist/src/scholarships/rules/SearchVolumeDisciplinesRule.js

@@ -0,0 +1,38 @@
+import { FilterKey } from "@studyportals/search-filters";
+export class SearchVolumeDisciplinesRule {
+    static instance;
+    disciplinesWithNoSearchVolume;
+    constructor() {
+        this.disciplinesWithNoSearchVolume = [
+            243, 415, 405, 379, 269, 413,
+            408, 274, 411, 401, 381, 390,
+            410, 412, 130
+        ];
+    }
+    static getInstance() {
+        if (!SearchVolumeDisciplinesRule.instance) {
+            SearchVolumeDisciplinesRule.instance = new SearchVolumeDisciplinesRule();
+        }
+        return SearchVolumeDisciplinesRule.instance;
+    }
+    forSearch(filterSet) {
+        const value = filterSet[FilterKey.DISCIPLINES];
+        if (!value) {
+            return false;
+        }
+        return this.hasSearchVolume(value);
+    }
+    forSitemapGenerator(filterSet) {
+        const value = filterSet[FilterKey.DISCIPLINES];
+        if (!value) {
+            throw new Error(`Invalid filter provided or undefined value.`);
+        }
+        return this.hasSearchVolume(value);
+    }
+    getName() {
+        return 'SearchVolumeDisciplinesRule';
+    }
+    hasSearchVolume(disciplineId) {
+        return !this.disciplinesWithNoSearchVolume.includes(Number(disciplineId));
+    }
+}