@studyportals/fawkes 8.0.1-0 → 8.0.1-1

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

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

package/dist/src/presenters/DurationPresenter.js

@@ -0,0 +1,47 @@
+import { DurationFilterOptionValue, FilterKey } from '@studyportals/search-filters';
+export class DurationPresenter {
+    filterKey = FilterKey.DURATION;
+    static instance;
+    fragments;
+    static INDEXABLE_DURATIONS = [
+        DurationFilterOptionValue.ONE_YEAR,
+        DurationFilterOptionValue.TWO_YEARS,
+        DurationFilterOptionValue.THREE_YEARS,
+        DurationFilterOptionValue.FOUR_YEARS
+    ];
+    constructor() {
+        this.fragments = this.generatePaths();
+    }
+    static getInstance() {
+        if (!DurationPresenter.instance) {
+            DurationPresenter.instance = new DurationPresenter();
+        }
+        return DurationPresenter.instance;
+    }
+    generatePaths() {
+        return DurationPresenter.INDEXABLE_DURATIONS.map((duration) => ({
+            id: duration,
+            path: this.formatDurationPath(duration)
+        }));
+    }
+    formatDurationPath(duration) {
+        switch (duration) {
+            case DurationFilterOptionValue.ONE_YEAR:
+                return '1-year';
+            case DurationFilterOptionValue.TWO_YEARS:
+                return '2-years';
+            case DurationFilterOptionValue.THREE_YEARS:
+                return '3-years';
+            case DurationFilterOptionValue.FOUR_YEARS:
+                return '4-years';
+            default:
+                return duration.toLowerCase().replace(/_/g, '-');
+        }
+    }
+    getFragments() {
+        return this.fragments;
+    }
+    isIndexableDuration(value) {
+        return DurationPresenter.INDEXABLE_DURATIONS.includes(value);
+    }
+}

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

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

package/dist/src/presenters/EducationalFormPresenter.js

@@ -0,0 +1,45 @@
+import { EducationalFormFilterOptionValue, FilterKey } from '@studyportals/search-filters';
+export class EducationalFormPresenter {
+    filterKey = FilterKey.EDUCATIONAL_FORM;
+    static instance;
+    fragments;
+    constructor() {
+        const indexableEducationalForms = [
+            EducationalFormFilterOptionValue.ACADEMIC_COURSE,
+            EducationalFormFilterOptionValue.SUMMER_SCHOOL,
+            EducationalFormFilterOptionValue.SEMESTER_STUDY_ABROAD,
+            EducationalFormFilterOptionValue.SKILL_PROFESSIONAL_COURSE
+        ];
+        this.fragments = indexableEducationalForms.map((form) => {
+            return {
+                id: form,
+                path: this.formatEducationalFormPath(form)
+            };
+        });
+    }
+    static getInstance() {
+        if (!EducationalFormPresenter.instance) {
+            EducationalFormPresenter.instance = new EducationalFormPresenter();
+        }
+        return EducationalFormPresenter.instance;
+    }
+    formatEducationalFormPath(form) {
+        switch (form) {
+            case EducationalFormFilterOptionValue.ACADEMIC_COURSE:
+                return 'academic-course';
+            case EducationalFormFilterOptionValue.CONFERENCE_SEMINAR:
+                return 'conference';
+            case EducationalFormFilterOptionValue.SUMMER_SCHOOL:
+                return 'summer-school';
+            case EducationalFormFilterOptionValue.WINTER_SCHOOL:
+                return 'winter-school';
+            case EducationalFormFilterOptionValue.SEMESTER_STUDY_ABROAD:
+                return 'semester-abroad';
+            case EducationalFormFilterOptionValue.SKILL_PROFESSIONAL_COURSE:
+                return 'skill';
+        }
+    }
+    getFragments() {
+        return this.fragments;
+    }
+}

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

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

package/dist/src/presenters/FormatPresenter.js

@@ -0,0 +1,24 @@
+import { FormatFilterOptionValue, FilterKey } from '@studyportals/search-filters';
+export class FormatPresenter {
+    filterKey = FilterKey.ATTENDANCE;
+    static instance;
+    fragments;
+    constructor() {
+        // Part-time is the only indexable format according to PartTimeFormatRule
+        this.fragments = [
+            {
+                id: FormatFilterOptionValue.PART_TIME,
+                path: 'part-time'
+            }
+        ];
+    }
+    static getInstance() {
+        if (!FormatPresenter.instance) {
+            FormatPresenter.instance = new FormatPresenter();
+        }
+        return FormatPresenter.instance;
+    }
+    getFragments() {
+        return this.fragments;
+    }
+}

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

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

package/dist/src/presenters/SpecialProgrammesPresenter.js

@@ -0,0 +1,27 @@
+import { SpecialProgrammesFilterOptionValue, FilterKey } from '@studyportals/search-filters';
+export class SpecialProgrammesPresenter {
+    filterKey = FilterKey.SPECIAL_PROGRAMMES;
+    static instance;
+    fragments;
+    constructor() {
+        this.fragments = [
+            {
+                id: SpecialProgrammesFilterOptionValue.JOINT_PROGRAMMES,
+                path: 'joint-programmes'
+            },
+            {
+                id: SpecialProgrammesFilterOptionValue.ERASMUS_MUNDUS,
+                path: 'erasmus-mundus'
+            }
+        ];
+    }
+    static getInstance() {
+        if (!SpecialProgrammesPresenter.instance) {
+            SpecialProgrammesPresenter.instance = new SpecialProgrammesPresenter();
+        }
+        return SpecialProgrammesPresenter.instance;
+    }
+    getFragments() {
+        return this.fragments;
+    }
+}

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

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

package/dist/src/presenters/TuitionFeePresenter.js

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

package/dist/src/presenters/fragments/IAreaFragment.d.ts

@@ -0,0 +1,4 @@
+import { IFragment } from './IFragment';
+export interface IAreaFragment extends IFragment {
+    countryId: string;
+}

package/dist/src/presenters/fragments/IAreaFragment.js

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

package/dist/src/presenters/fragments/ICountryFragment.d.ts

@@ -0,0 +1,4 @@
+import { IFragment } from './IFragment';
+export interface ICountryFragment extends IFragment {
+    readonly iso: string;
+}

package/dist/src/presenters/fragments/ICountryFragment.js

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

package/dist/src/presenters/fragments/IFragment.d.ts

@@ -0,0 +1,4 @@
+export interface IFragment {
+    id: string;
+    path: string;
+}

package/dist/src/presenters/fragments/IFragment.js

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

package/dist/src/programmes/BaseProgrammeFilterKeyValueRule.d.ts

@@ -0,0 +1,6 @@
+import { BaseFilterKeyValueRule } from '../common/rules/BaseFilterKeyValueRule';
+import { FilterKeyValuesMap } from '../common/FilterKeyValuesMap';
+import { IProgrammeRule } from './IProgrammeRule';
+export declare abstract class BaseProgrammeFilterKeyValueRule extends BaseFilterKeyValueRule implements IProgrammeRule {
+    forSitemapGeneratorWithPageNumber(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

package/dist/src/programmes/BaseProgrammeFilterKeyValueRule.js

@@ -0,0 +1,6 @@
+import { BaseFilterKeyValueRule } from '../common/rules/BaseFilterKeyValueRule';
+export class BaseProgrammeFilterKeyValueRule extends BaseFilterKeyValueRule {
+    forSitemapGeneratorWithPageNumber(filterKeyValues) {
+        return this.forSitemapGenerator(filterKeyValues);
+    }
+}

package/dist/src/programmes/BaseProgrammeRule.d.ts

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

package/dist/src/programmes/BaseProgrammeRule.js

@@ -0,0 +1,5 @@
+export class BaseProgrammeRule {
+    forSitemapGeneratorWithPageNumber(filterKeyValues) {
+        return this.forSitemapGenerator(filterKeyValues);
+    }
+}

package/dist/src/programmes/IProgrammeRule.d.ts

@@ -0,0 +1,5 @@
+import { IRule } from '../common/IRule';
+import { FilterKeyValuesMap } from '../common/FilterKeyValuesMap';
+export interface IProgrammeRule extends IRule {
+    forSitemapGeneratorWithPageNumber(filterKeyValues: FilterKeyValuesMap, pageNumber: number): Promise<boolean>;
+}

package/dist/src/programmes/IProgrammeRule.js

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

package/dist/src/programmes/ProgrammesBaseIndexabilityPolicy.d.ts

@@ -0,0 +1,15 @@
+import { BaseSeoIndexabilityPolicy } from '../common/policies/BaseSeoIndexabilityPolicy';
+import { IProgrammeSeoDependencies } from './types/IProgrammeSeoDependencies';
+import { IProgrammeSitemapUrlGenerator } from './types/IProgrammeSitemapUrlGenerator';
+import { FilterKey } from '@studyportals/search-filters';
+import { FilterKeyValuesMap } from '../../sitemap-generator-seo';
+import { IProgrammeRule } from './IProgrammeRule';
+import { IRule } from '../common/IRule';
+export declare abstract class ProgrammesBaseIndexabilityPolicy extends BaseSeoIndexabilityPolicy<IProgrammeSeoDependencies> implements IProgrammeSitemapUrlGenerator {
+    abstract readonly filterKeys: FilterKey[];
+    protected readonly indexablePageNumbers: number[];
+    protected abstract readonly rules: IProgrammeRule[] | IRule[];
+    protected initateBaseRules(): void;
+    checkRulesForSitemapWithPageNumber(filterKeyValues: FilterKeyValuesMap, pageNumber: number): Promise<boolean>;
+    protected getPathWithPageNumber(path: string, pageNumber: number): string;
+}

package/dist/src/programmes/ProgrammesBaseIndexabilityPolicy.js

@@ -0,0 +1,42 @@
+import { AtLeastSevenResultsRule } from './rules/AtLeastSevenResultsRule';
+import { IndexablePageNumberRule } from './rules/IndexablePageNumberRule';
+import { NotDistanceLearningPortalRule } from './rules/NotDistanceLearningPortalRule';
+import { BaseSeoIndexabilityPolicy } from '../common/policies/BaseSeoIndexabilityPolicy';
+export class ProgrammesBaseIndexabilityPolicy extends BaseSeoIndexabilityPolicy {
+    indexablePageNumbers = [1];
+    initateBaseRules() {
+        const indexablePageNumberRule = new IndexablePageNumberRule();
+        let atLeastSevenResultsRule;
+        let notDistanceLearningPortalRule;
+        if (super.isSitemapUrlGeneratorDependencies()) {
+            const dependencies = this.dependencies;
+            atLeastSevenResultsRule = new AtLeastSevenResultsRule(dependencies.searchApiClient);
+            notDistanceLearningPortalRule = new NotDistanceLearningPortalRule(dependencies.portalType);
+        }
+        else {
+            atLeastSevenResultsRule = new AtLeastSevenResultsRule();
+            notDistanceLearningPortalRule = new NotDistanceLearningPortalRule();
+        }
+        this.rules.push(atLeastSevenResultsRule, notDistanceLearningPortalRule, indexablePageNumberRule);
+    }
+    async checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber) {
+        for (const rule of this.rules) {
+            let result;
+            if ('forSitemapGeneratorWithPageNumber' in rule) {
+                result = await rule.forSitemapGeneratorWithPageNumber(filterKeyValues, pageNumber);
+            }
+            else {
+                result = await rule.forSitemapGenerator(filterKeyValues);
+            }
+            if (!result) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getPathWithPageNumber(path, pageNumber) {
+        if (pageNumber === 2)
+            return `${path}/page-${pageNumber}`;
+        return path;
+    }
+}

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

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

package/dist/src/programmes/SearchIndexabilityManager.js

@@ -0,0 +1,58 @@
+import { Area, Attendance, AttendanceDegree, Continent, ContinentTuitionFee, Country, CountryAttendance, CountryAttendanceDegree, CountryDegree, CountryDuration, CountryDurationDegree, CountryEducationalForm, CountryFormat, CountryTuitionFee, DegreeAttendanceDiscipline, DegreeCountryAttendance, DegreeCountryDiscipline, DegreeCountryTuitionFee, Discipline, DisciplineArea, DisciplineAttendance, DisciplineContinent, DisciplineCountry, DisciplineCountryEducationalForm, DisciplineDegree, DisciplineDuration, DisciplineEducationalForm, DisciplineFormat, DisciplineTuitionFee, DisciplineTuitionFeeAttendance, SpecialProgrammes, TuitionFee, Unfiltered } from './policies';
+import { DependencyTypes } from '../enums/DependencyTypes';
+import { Degree } from './policies/Degree';
+export class SearchIndexabilityManager {
+    policies;
+    constructor(portalType, seoInfoBase, filterState, applicationState) {
+        const dependencies = {
+            dependencyType: DependencyTypes.SEARCH,
+            portalType,
+            seoInfoBase,
+            filterState,
+            applicationState
+        };
+        this.policies = [
+            new Area(dependencies),
+            new Attendance(dependencies),
+            new AttendanceDegree(dependencies),
+            new Continent(dependencies),
+            new ContinentTuitionFee(dependencies),
+            new Country(dependencies),
+            new CountryAttendance(dependencies),
+            new CountryAttendanceDegree(dependencies),
+            new CountryDegree(dependencies),
+            new CountryDuration(dependencies),
+            new CountryDurationDegree(dependencies),
+            new CountryEducationalForm(dependencies),
+            new CountryFormat(dependencies),
+            new CountryTuitionFee(dependencies),
+            new Degree(dependencies),
+            new DegreeAttendanceDiscipline(dependencies),
+            new DegreeCountryAttendance(dependencies),
+            new DegreeCountryDiscipline(dependencies),
+            new DegreeCountryTuitionFee(dependencies),
+            new Discipline(dependencies),
+            new DisciplineArea(dependencies),
+            new DisciplineAttendance(dependencies),
+            new DisciplineContinent(dependencies),
+            new DisciplineCountry(dependencies),
+            new DisciplineCountryEducationalForm(dependencies),
+            new DisciplineDegree(dependencies),
+            new DisciplineDuration(dependencies),
+            new DisciplineEducationalForm(dependencies),
+            new DisciplineFormat(dependencies),
+            new DisciplineTuitionFee(dependencies),
+            new DisciplineTuitionFeeAttendance(dependencies),
+            new SpecialProgrammes(dependencies),
+            new TuitionFee(dependencies),
+            new Unfiltered(dependencies)
+        ];
+    }
+    getPolicies() {
+        return this.policies;
+    }
+    async shouldIndex() {
+        const results = await Promise.all(this.policies.map((policy) => policy.shouldIndex()));
+        return results.some((result) => result);
+    }
+}

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

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

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

@@ -0,0 +1,40 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { AreaPresenter } from '../../presenters/AreaPresenter';
+export class Area extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Area Policy';
+    description = 'Controls indexing of pages filtered by geographic areas.';
+    filterKeys = [FilterKey.AREA];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.AREA),
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY])
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const areaFragments = AreaPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const area of areaFragments) {
+                const filterKeyValues = new Map([
+                    [FilterKey.AREA, [area.id]],
+                    [FilterKey.COUNTRY, [area.countryId]]
+                ]);
+                const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                if (result) {
+                    paths.push(this.getPathWithPageNumber(area.path, pageNumber));
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.AREA;
+    }
+}

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

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

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

@@ -0,0 +1,38 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { AttendancePresenter } from '../../presenters/AttendancePresenter';
+export class Attendance extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Attendance Policy';
+    description = 'Determines indexing rules for pages filtered by study format (online, on-campus, etc.).';
+    filterKeys = [FilterKey.DELIVERY_METHOD];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new OnlyFiltersSelectedRule([FilterKey.DELIVERY_METHOD]),
+        new OnlineAttendanceRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const attendance of attendanceFragments) {
+                const filterKeyValues = new Map([[FilterKey.DELIVERY_METHOD, [attendance.id]]]);
+                const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                if (result) {
+                    paths.push(this.getPathWithPageNumber(attendance.path, pageNumber));
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.ATTENDANCE;
+    }
+}

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

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

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

@@ -0,0 +1,48 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
+import { IndexableDegreeRule } from '../rules/IndexableDegreeRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { AttendancePresenter } from '../../presenters/AttendancePresenter';
+import { DegreePresenter } from '../../presenters/DegreePresenter';
+export class AttendanceDegree extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Attendance Degree Type Policy';
+    description = 'Determines indexing rules for pages filtered by both study format (online, on-campus, etc.), and degree type prioritizing degrees and formats with demonstrated search demand.';
+    filterKeys = [FilterKey.DELIVERY_METHOD, FilterKey.DEGREE_TYPE];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
+        new OnlyFiltersSelectedRule([FilterKey.DELIVERY_METHOD, FilterKey.DEGREE_TYPE]),
+        new IndexableDegreeRule(),
+        new OnlineAttendanceRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const degreeFragments = DegreePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const attendance of attendanceFragments) {
+                for (const degree of degreeFragments) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.DELIVERY_METHOD, [attendance.id]],
+                        [FilterKey.DEGREE_TYPE, [degree.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${degree.path}/${attendance.path}`, pageNumber));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.ATTENDANCE_DEGREE;
+    }
+}

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

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