@studyportals/fawkes 8.0.1-0 → 8.0.1-1

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

@@ -0,0 +1,21 @@
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { NoFiltersSelectedRule } from '../../../common/rules/NoFiltersSelectedRule';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedUnfiltered extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Unfiltered Policy';
+    description = 'Defines indexing rules for ranking-sorted unfiltered pages, managing SEO strategy for quality-ordered aggregate views of the content database.';
+    baseRules = [new NoFiltersSelectedRule()];
+    constructor(dependencies) {
+        super(dependencies);
+    }
+    async generateUrls() {
+        const filterKeyValues = new Map([]);
+        if (await this.checkRulesForSitemap(filterKeyValues)) {
+            return [this.getPathWithSortingOption('')];
+        }
+        return [];
+    }
+    get filterCombination() {
+        return FilterCombinations.RANKED_UNFILTERED;
+    }
+}

package/dist/src/organisations/rules/AtLeastSevenResultsRule.d.ts

@@ -0,0 +1,15 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { ISearchApiClient } from '../../sitemap-generator/ISearchApiClient';
+import { IRule } from '../../common/IRule';
+export declare class AtLeastSevenResultsRule implements IRule {
+    private readonly minimumResultsCount;
+    private readonly maximumPageSize;
+    private readonly searchApiClient?;
+    constructor(searchApiClient?: ISearchApiClient);
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGeneratorWithPageNumber(filterKeyValues: FilterKeyValuesMap, pageNumber: number): Promise<boolean>;
+    forSitemapGenerator(): Promise<boolean>;
+    getName(): string;
+    getDescription(): string;
+}

package/dist/src/organisations/rules/AtLeastSevenResultsRule.js

@@ -0,0 +1,30 @@
+import { DependencyMissingError } from '../../errors/DependencyMissingError';
+export class AtLeastSevenResultsRule {
+    minimumResultsCount = 7;
+    maximumPageSize = 20;
+    searchApiClient;
+    constructor(searchApiClient) {
+        this.searchApiClient = searchApiClient;
+    }
+    forSearch(dependencies) {
+        const { applicationState } = dependencies;
+        const resultCount = applicationState.getNumberOfResults();
+        return Promise.resolve(resultCount >= this.minimumResultsCount);
+    }
+    async forSitemapGeneratorWithPageNumber(filterKeyValues, pageNumber) {
+        if (!this.searchApiClient) {
+            throw new DependencyMissingError('SearchApiClient');
+        }
+        const count = await this.searchApiClient.getCount(filterKeyValues);
+        return count >= (pageNumber - 1) * this.maximumPageSize + this.minimumResultsCount;
+    }
+    forSitemapGenerator() {
+        throw new Error('Method not implemented.');
+    }
+    getName() {
+        return 'AtLeastSevenResultsRule';
+    }
+    getDescription() {
+        return 'Is indexable if there are at least 2 results.';
+    }
+}

package/dist/src/organisations/rules/AtLeastTwoRankedResultsRule.d.ts

@@ -0,0 +1,13 @@
+import { IRule } from '../../common/IRule';
+import { IOrganisationSearchDependencies } from '../types/IOrganisationSearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { IRankingApiClient } from '../../sitemap-generator/IRankingApiClient';
+export declare class AtLeastTwoRankedResultsRule implements IRule {
+    private readonly minimumRankedResultsCount;
+    private readonly rankingApiClient?;
+    constructor(rankingApiClient?: IRankingApiClient);
+    forSearch(dependencies: IOrganisationSearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+    getName(): string;
+    getDescription(): string;
+}

package/dist/src/organisations/rules/AtLeastTwoRankedResultsRule.js

@@ -0,0 +1,26 @@
+import { DependencyMissingError } from '../../errors/DependencyMissingError';
+export class AtLeastTwoRankedResultsRule {
+    minimumRankedResultsCount = 2;
+    rankingApiClient;
+    constructor(rankingApiClient) {
+        this.rankingApiClient = rankingApiClient;
+    }
+    forSearch(dependencies) {
+        const { applicationState } = dependencies;
+        const rankedResultsCount = applicationState.getRankedResultsCount();
+        return Promise.resolve(rankedResultsCount >= this.minimumRankedResultsCount);
+    }
+    async forSitemapGenerator(filterKeyValues) {
+        if (!this.rankingApiClient) {
+            throw new DependencyMissingError('RankingApiClient');
+        }
+        const rankedResultsCount = await this.rankingApiClient.getRankedOrganisationCount(filterKeyValues);
+        return rankedResultsCount >= this.minimumRankedResultsCount;
+    }
+    getName() {
+        return 'AtLeastTwoRankedResultsRule';
+    }
+    getDescription() {
+        return `At least ${this.minimumRankedResultsCount} ranked results are available`;
+    }
+}

package/dist/src/organisations/rules/BaseSearchVolumeOrganisationsRule.d.ts

@@ -0,0 +1,14 @@
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { IRule } from '../../common/IRule';
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKey } from '@studyportals/search-filters';
+export declare abstract class BaseSearchVolumeOrganisationsRule implements IRule {
+    private readonly filterKey;
+    private readonly idsWithSearchVolume;
+    constructor(filterKey: FilterKey, idsWithSearchVolume: string[]);
+    abstract getName(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+    private hasSearchVolume;
+    getDescription(): string;
+}

package/dist/src/organisations/rules/BaseSearchVolumeOrganisationsRule.js

@@ -0,0 +1,33 @@
+export class BaseSearchVolumeOrganisationsRule {
+    filterKey;
+    idsWithSearchVolume;
+    constructor(filterKey, idsWithSearchVolume) {
+        this.filterKey = filterKey;
+        this.idsWithSearchVolume = idsWithSearchVolume;
+    }
+    forSearch(dependencies) {
+        const value = dependencies.seoInfoBase.getFilterOptionValueBy(this.filterKey, dependencies.filterState);
+        if (!value) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.hasSearchVolume(value));
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const values = filterKeyValues.get(this.filterKey);
+        if (!values) {
+            return Promise.resolve(false);
+        }
+        for (const value of values) {
+            if (!this.idsWithSearchVolume.includes(value)) {
+                return Promise.resolve(false);
+            }
+        }
+        return Promise.resolve(true);
+    }
+    hasSearchVolume(value) {
+        return this.idsWithSearchVolume.includes(value);
+    }
+    getDescription() {
+        return `Indexable if ${this.filterKey} has search volume`;
+    }
+}

package/dist/src/organisations/rules/ContinentIsEuropeRule.d.ts

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

package/dist/src/organisations/rules/ContinentIsEuropeRule.js

@@ -0,0 +1,15 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseFilterKeyValueRule } from '../../common/rules/BaseFilterKeyValueRule';
+export class ContinentIsEuropeRule extends BaseFilterKeyValueRule {
+    constructor() {
+        const europeId = '1';
+        const filterKeyValues = new Map([[FilterKey.CONTINENT, [europeId]]]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'ContinentIsEuropeRule';
+    }
+    getDescription() {
+        return 'Indexable if continent is Europe';
+    }
+}

package/dist/src/organisations/rules/NoFiltersSelectedRule.d.ts

@@ -0,0 +1,9 @@
+import { IRule } from '../../common/IRule';
+import { IOrganisationSearchDependencies } from '../types/IOrganisationSearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+export declare class NoFiltersSelectedRule implements IRule {
+    forSearch(dependencies: IOrganisationSearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+    getName(): string;
+    getDescription(): string;
+}

package/dist/src/organisations/rules/NoFiltersSelectedRule.js

@@ -0,0 +1,17 @@
+export class NoFiltersSelectedRule {
+    forSearch(dependencies) {
+        const { filterState, seoInfoBase } = dependencies;
+        const selectionCount = seoInfoBase.getSelectionTypeCount(filterState);
+        return Promise.resolve(selectionCount === 0);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    forSitemapGenerator(filterKeyValues) {
+        throw new Error('Method not implemented.');
+    }
+    getName() {
+        return 'Indexable if no filters are selected.';
+    }
+    getDescription() {
+        throw new Error('Method not implemented.');
+    }
+}

package/dist/src/organisations/rules/SearchVolumeAreasAttendanceRule.d.ts

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

package/dist/src/organisations/rules/SearchVolumeAreasAttendanceRule.js

@@ -0,0 +1,17 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseSearchVolumeOrganisationsRule } from './BaseSearchVolumeOrganisationsRule';
+export class SearchVolumeAreasAttendanceRule extends BaseSearchVolumeOrganisationsRule {
+    constructor() {
+        const areaIdsWithSearchVolume = [
+            3592, 3615, 3610, 3597, 3611, 3581, 3584, 3604, 3605, 3585, 3628, 3594, 3600, 3606, 3590, 3591, 3586, 3578, 3601, 3582, 3588, 3624,
+            3616, 3598, 3596, 3583, 3626, 3587, 3613, 3589, 3614, 3621, 3609, 3595, 3623, 3625, 3618, 3619, 3627, 993, 996
+        ];
+        super(FilterKey.AREA, areaIdsWithSearchVolume.map((id) => id.toString()));
+    }
+    getName() {
+        return 'SearchVolumeAreasAttendanceRule';
+    }
+    getDescription() {
+        return 'Indexable if area has search volume';
+    }
+}

package/dist/src/organisations/rules/SearchVolumeAreasDisciplineRule.d.ts

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

package/dist/src/organisations/rules/SearchVolumeAreasDisciplineRule.js

@@ -0,0 +1,18 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseSearchVolumeOrganisationsRule } from './BaseSearchVolumeOrganisationsRule';
+export class SearchVolumeAreasDisciplineRule extends BaseSearchVolumeOrganisationsRule {
+    constructor() {
+        const areaIdsWithSearchVolume = [
+            3578, 3579, 3580, 3581, 3582, 3583, 3584, 3585, 3586, 3587, 3588, 3589, 3590, 3591, 3592, 3593, 3594, 3595, 3596, 3597, 3598, 3599,
+            3600, 3601, 3602, 3603, 3604, 3605, 3606, 3607, 3608, 3609, 3610, 3611, 3612, 3613, 3614, 3615, 3616, 3617, 3618, 3619, 3620, 3621,
+            3622, 3623, 3624, 3625, 3626, 3627, 3628
+        ];
+        super(FilterKey.AREA, areaIdsWithSearchVolume.map((id) => id.toString()));
+    }
+    getName() {
+        return 'SearchVolumeAreasDisciplineRule';
+    }
+    getDescription() {
+        return 'Indexable if area has search volume';
+    }
+}

package/dist/src/organisations/rules/SearchVolumeCountriesAttendanceRule.d.ts

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

package/dist/src/organisations/rules/SearchVolumeCountriesAttendanceRule.js

@@ -0,0 +1,17 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseSearchVolumeOrganisationsRule } from './BaseSearchVolumeOrganisationsRule';
+export class SearchVolumeCountriesAttendanceRule extends BaseSearchVolumeOrganisationsRule {
+    constructor() {
+        const countryIdsWithSearchVolume = [
+            108, 30, 202, 56, 106, 24, 10, 14, 15, 69, 71, 76, 82, 151, 105, 161, 167, 112, 113, 170, 129, 131, 132, 191, 9, 11, 20, 22, 27, 28,
+            121, 185, 117, 197, 212
+        ];
+        super(FilterKey.COUNTRY, countryIdsWithSearchVolume.map((id) => id.toString()));
+    }
+    getName() {
+        return 'SearchVolumeCountriesAttendanceRule';
+    }
+    getDescription() {
+        return 'Indexable if country has search volume';
+    }
+}

package/dist/src/organisations/types/IOrganisationSearchDependencies.d.ts

@@ -0,0 +1,9 @@
+import { ISeoSortingState } from '../../organisations/ISeoSortingState';
+import { PortalType } from '@studyportals/domain-client';
+import { IOrganisationSearchApplicationState } from '../IOrganisationSearchApplicationState';
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+export interface IOrganisationSearchDependencies extends ISearchDependencies {
+    portalType: PortalType;
+    sortingState: ISeoSortingState;
+    applicationState: IOrganisationSearchApplicationState;
+}

package/dist/src/organisations/types/IOrganisationSearchDependencies.js

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

package/dist/src/organisations/types/IOrganisationsSeoDependencies.d.ts

@@ -0,0 +1,3 @@
+import { IOrganisationSearchDependencies } from './IOrganisationSearchDependencies';
+import { IOrganisationsSitemapDependencies } from './IOrganisationsSitemapDependencies';
+export type IOrganisationsSeoDependencies = IOrganisationSearchDependencies | IOrganisationsSitemapDependencies;

package/dist/src/organisations/types/IOrganisationsSeoDependencies.js

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

package/dist/src/organisations/types/IOrganisationsSitemapDependencies.d.ts

@@ -0,0 +1,9 @@
+import { ISitemapDependencies } from '../../common/ISitemapDependencies';
+import { IRankingApiClient } from '../../sitemap-generator/IRankingApiClient';
+import { PortalType } from '@studyportals/domain-client';
+import { IOrganisationsClient } from '../../sitemap-generator/IOrganisationsClient';
+export interface IOrganisationsSitemapDependencies extends ISitemapDependencies {
+    organisationsClient: IOrganisationsClient;
+    portalType: PortalType;
+    rankingApiClient: IRankingApiClient;
+}

package/dist/src/organisations/types/IOrganisationsSitemapDependencies.js

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

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

@@ -0,0 +1,6 @@
+export declare const types: {
+    SeoInfoBase: symbol;
+    SeoFilterState: symbol;
+    SeoApplicationState: symbol;
+    SeoSortingState: symbol;
+};

package/dist/src/organisations/types.js

@@ -0,0 +1,6 @@
+export const types = {
+    SeoInfoBase: Symbol.for('ISeoInfoBase'),
+    SeoFilterState: Symbol.for('ISeoFilterState'),
+    SeoApplicationState: Symbol.for('IOrganisationSearchApplicationState'),
+    SeoSortingState: Symbol.for('ISeoSortingState')
+};

package/dist/src/presenters/AreaPresenter.d.ts

@@ -0,0 +1,12 @@
+import { IAreaFragment } from './fragments/IAreaFragment';
+import { IPresenter } from '../common';
+import { FilterKey } from '@studyportals/search-filters';
+export declare class AreaPresenter implements IPresenter {
+    readonly filterKey: FilterKey;
+    private static instance;
+    private readonly fragments;
+    private constructor();
+    static getInstance(): AreaPresenter;
+    private generatePaths;
+    getFragments(): IAreaFragment[];
+}

package/dist/src/presenters/AreaPresenter.js

@@ -0,0 +1,35 @@
+import { areasAll } from '@studyportals/static-domain-data/areas/areas';
+import { areaGetPath } from '@studyportals/static-domain-data/areas/area-get-path';
+import { FilterKey } from '@studyportals/search-filters';
+export class AreaPresenter {
+    filterKey = FilterKey.AREA;
+    static instance;
+    fragments;
+    constructor() {
+        this.fragments = this.generatePaths();
+    }
+    static getInstance() {
+        if (!AreaPresenter.instance) {
+            AreaPresenter.instance = new AreaPresenter();
+        }
+        return AreaPresenter.instance;
+    }
+    generatePaths() {
+        const areas = [];
+        areasAll.forEach((area) => {
+            const path = areaGetPath(area.id);
+            if (path === null) {
+                return;
+            }
+            areas.push({
+                id: area.id,
+                path,
+                countryId: area.countryId
+            });
+        });
+        return areas;
+    }
+    getFragments() {
+        return this.fragments;
+    }
+}

package/dist/src/presenters/AttendancePresenter.d.ts

@@ -0,0 +1,11 @@
+import { IPresenter } from '../common';
+import { IFragment } from './fragments/IFragment';
+import { FilterKey } from '@studyportals/search-filters';
+export declare class AttendancePresenter implements IPresenter {
+    readonly filterKey: FilterKey;
+    private static instance;
+    private readonly fragments;
+    private constructor();
+    static getInstance(): AttendancePresenter;
+    getFragments(): IFragment[];
+}

package/dist/src/presenters/AttendancePresenter.js

@@ -0,0 +1,23 @@
+import { FilterKey } from '@studyportals/search-filters';
+export class AttendancePresenter {
+    filterKey = FilterKey.DELIVERY_METHOD;
+    static instance;
+    fragments;
+    constructor() {
+        this.fragments = [
+            {
+                id: 'online',
+                path: 'online'
+            }
+        ];
+    }
+    static getInstance() {
+        if (!AttendancePresenter.instance) {
+            AttendancePresenter.instance = new AttendancePresenter();
+        }
+        return AttendancePresenter.instance;
+    }
+    getFragments() {
+        return this.fragments;
+    }
+}

package/dist/src/presenters/ContinentPresenter.d.ts

@@ -0,0 +1,12 @@
+import { IFragment } from './fragments/IFragment';
+import { IPresenter } from '../common';
+import { FilterKey } from '@studyportals/search-filters';
+export declare class ContinentPresenter implements IPresenter {
+    readonly filterKey: FilterKey;
+    private static instance;
+    private readonly fragments;
+    private constructor();
+    static getInstance(): ContinentPresenter;
+    private generatePaths;
+    getFragments(): IFragment[];
+}

package/dist/src/presenters/ContinentPresenter.js

@@ -0,0 +1,33 @@
+import { continentsAll } from '@studyportals/static-domain-data/continents/continents';
+import { continentGetPath } from '@studyportals/static-domain-data/continents/continent-get-path';
+import { FilterKey } from '@studyportals/search-filters';
+export class ContinentPresenter {
+    filterKey = FilterKey.CONTINENT;
+    static instance;
+    fragments;
+    constructor() {
+        this.fragments = this.generatePaths();
+    }
+    static getInstance() {
+        if (!ContinentPresenter.instance) {
+            ContinentPresenter.instance = new ContinentPresenter();
+        }
+        return ContinentPresenter.instance;
+    }
+    generatePaths() {
+        const continents = [];
+        for (const continent of continentsAll) {
+            const path = continentGetPath(continent.id);
+            if (path) {
+                continents.push({
+                    id: continent.id,
+                    path
+                });
+            }
+        }
+        return continents;
+    }
+    getFragments() {
+        return this.fragments;
+    }
+}

package/dist/src/presenters/CountryPresenter.d.ts

@@ -0,0 +1,12 @@
+import { ICountryFragment } from './fragments/ICountryFragment';
+import { IPresenter } from '../common';
+import { FilterKey } from '@studyportals/search-filters';
+export declare class CountryPresenter implements IPresenter {
+    readonly filterKey: FilterKey;
+    private static instance;
+    private readonly fragments;
+    private constructor();
+    static getInstance(): CountryPresenter;
+    private generatePaths;
+    getFragments(): ICountryFragment[];
+}

package/dist/src/presenters/CountryPresenter.js

@@ -0,0 +1,38 @@
+import { countriesExtendedAll } from '@studyportals/static-domain-data/countries/countries-extended';
+import { countryGetIsoCodePath } from '@studyportals/static-domain-data/countries/country-get-iso-path';
+import { FilterKey } from '@studyportals/search-filters';
+export class CountryPresenter {
+    filterKey = FilterKey.COUNTRY;
+    static instance;
+    fragments;
+    constructor() {
+        this.fragments = this.generatePaths();
+    }
+    static getInstance() {
+        if (!CountryPresenter.instance) {
+            CountryPresenter.instance = new CountryPresenter();
+        }
+        return CountryPresenter.instance;
+    }
+    generatePaths() {
+        const countries = [];
+        countriesExtendedAll.forEach((country) => {
+            if (!country.iso) {
+                return;
+            }
+            const path = countryGetIsoCodePath(country.iso);
+            if (path === null) {
+                return;
+            }
+            countries.push({
+                id: country.id,
+                iso: country.iso,
+                path
+            });
+        });
+        return countries;
+    }
+    getFragments() {
+        return this.fragments;
+    }
+}

package/dist/src/presenters/DegreePresenter.d.ts

@@ -0,0 +1,12 @@
+import { IPresenter } from '../common';
+import { IFragment } from './fragments/IFragment';
+import { FilterKey } from '@studyportals/search-filters';
+export declare class DegreePresenter implements IPresenter {
+    readonly filterKey: FilterKey;
+    private static instance;
+    private readonly fragments;
+    private constructor();
+    static getInstance(): DegreePresenter;
+    getFragments(): IFragment[];
+    private formatDegreePath;
+}

package/dist/src/presenters/DegreePresenter.js

@@ -0,0 +1,50 @@
+import { DegreeTypeFilterOptionValue, FilterKey } from '@studyportals/search-filters';
+export class DegreePresenter {
+    filterKey = FilterKey.DEGREE_TYPE;
+    static instance;
+    fragments;
+    constructor() {
+        this.fragments = Object.values(DegreeTypeFilterOptionValue).map((degree) => {
+            return {
+                id: degree,
+                path: this.formatDegreePath(degree)
+            };
+        });
+    }
+    static getInstance() {
+        if (!DegreePresenter.instance) {
+            DegreePresenter.instance = new DegreePresenter();
+        }
+        return DegreePresenter.instance;
+    }
+    getFragments() {
+        return this.fragments;
+    }
+    formatDegreePath(degree) {
+        const formattedDegree = degree.toLowerCase().replace(/_/g, '-');
+        const pathById = new Map([
+            ['phd', 'ph-d'],
+            ['dba', 'dba'],
+            ['doct', 'doctorate'],
+            ['msc', 'msc'],
+            ['ma', 'ma'],
+            ['mba', 'mba'],
+            ['llm', 'llm'],
+            ['mphil', 'mphil'],
+            ['med', 'med'],
+            ['meng', 'meng'],
+            ['postgraddip', 'postgraduate-diploma'],
+            ['postgradcert', 'postgraduate-certificate'],
+            ['premaster', 'pre-master'],
+            ['bsc', 'bsc'],
+            ['ba', 'ba'],
+            ['bba', 'bba'],
+            ['ad', 'associate-degree'],
+            ['gcertificate', 'graduate-certificate'],
+            ['gdiploma', 'graduate-diploma'],
+            ['prebachelor', 'prebachelor'],
+            ['certificate', 'certificate']
+        ]);
+        return pathById.get(degree) || formattedDegree;
+    }
+}

package/dist/src/presenters/DisciplinePresenter.d.ts

@@ -0,0 +1,12 @@
+import { IFragment } from './fragments/IFragment';
+import { IPresenter } from '../common';
+import { FilterKey } from '@studyportals/search-filters';
+export declare class DisciplinePresenter implements IPresenter {
+    readonly filterKey: FilterKey;
+    private static instance;
+    private readonly fragments;
+    private constructor();
+    static getInstance(): DisciplinePresenter;
+    private generatePaths;
+    getFragments(): IFragment[];
+}

package/dist/src/presenters/DisciplinePresenter.js

@@ -0,0 +1,33 @@
+import { disciplinesAll } from '@studyportals/static-domain-data/disciplines/disciplines';
+import { subdisciplinesAll } from '@studyportals/static-domain-data/disciplines/subdisciplines';
+import { disciplineGetVirtualPath } from '@studyportals/static-domain-data/disciplines/discipline-get-virtual-path';
+import { FilterKey } from '@studyportals/search-filters';
+export class DisciplinePresenter {
+    filterKey = FilterKey.DISCIPLINES;
+    static instance;
+    fragments;
+    constructor() {
+        this.fragments = this.generatePaths();
+    }
+    static getInstance() {
+        if (!DisciplinePresenter.instance) {
+            DisciplinePresenter.instance = new DisciplinePresenter();
+        }
+        return DisciplinePresenter.instance;
+    }
+    generatePaths() {
+        const disciplines = [];
+        const allDisciplines = [...disciplinesAll, ...subdisciplinesAll];
+        allDisciplines.forEach((discipline) => {
+            const path = disciplineGetVirtualPath(discipline.id);
+            if (path === null) {
+                return;
+            }
+            disciplines.push({ id: discipline.id, path });
+        });
+        return disciplines;
+    }
+    getFragments() {
+        return this.fragments;
+    }
+}