@studyportals/fawkes 3.0.0 → 3.0.1-3

package/dist/organisations-seo/index.d.ts

@@ -0,0 +1,3 @@
+export * from "../src/common/ISeoInfoBase";
+export * from "../src/common/ISeoFilterState";
+export * from "../src/organisations";

package/dist/organisations-seo/index.js

@@ -1 +1,3 @@
-"use strict";
+export * from "../src/common/ISeoInfoBase";
+export * from "../src/common/ISeoFilterState";
+export * from "../src/organisations";

package/dist/scholarships-seo/index.d.ts

@@ -1,8 +1,6 @@
 import { ISeoFilterState } from "../src/common/ISeoFilterState";
 import { ISeoInfoBase } from "../src/common/ISeoInfoBase";
-import { ISeoFilterOptions } from "../src/common/ISeoFilterOptions";
-import { ISeoSearchApplicationState } from "../src/common/ISeoSearchApplicationState";
 import { ISearchIndexabilityManager } from "../src/common/ISearchIndexabilityManager";
 import { SearchIndexabilityManager } from "../src/scholarships/SearchIndexabilityManager";
 import { types } from "../src/scholarships/types";
-export { ISeoFilterState, ISeoInfoBase, ISeoFilterOptions, ISeoSearchApplicationState, ISearchIndexabilityManager, SearchIndexabilityManager, types };
+export { ISeoFilterState, ISeoInfoBase, ISearchIndexabilityManager, SearchIndexabilityManager, types };

package/dist/src/common/FilterKeyValuesMap.d.ts

@@ -0,0 +1,2 @@
+import { FilterKey } from "@studyportals/search-filters";
+export type FilterKeyValuesMap = Map<FilterKey, string[]>;

package/dist/src/common/IRule.d.ts

@@ -0,0 +1,7 @@
+import { FilterKeyValuesMap } from "./FilterKeyValuesMap";
+import { ISearchDependencies } from "./ISearchDependencies";
+export interface IRule {
+    getName(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

package/dist/src/common/ISearchApplicationState.d.ts

@@ -0,0 +1,3 @@
+export interface ISearchApplicationState {
+    getNumberOfResults(): number;
+}

package/dist/src/common/ISearchDependencies.d.ts

@@ -1,8 +1,7 @@
-import { ISeoInfoBase, ISeoFilterState, ISeoFilterOptions, ISeoSearchApplicationState } from "../common";
+import { ISeoInfoBase, ISeoFilterState, ISearchApplicationState } from "../common";
 import { IDependencies } from "./IDependencies";
 export interface ISearchDependencies extends IDependencies {
     seoInfoBase: ISeoInfoBase;
     filterState: ISeoFilterState;
-    filterOptions?: ISeoFilterOptions;
-    applicationState?: ISeoSearchApplicationState;
+    applicationState: ISearchApplicationState;
 }

package/dist/src/common/ISeoDependencies.d.ts

@@ -0,0 +1,3 @@
+import { ISearchDependencies } from "../common/ISearchDependencies";
+import { ISitemapDependencies } from "../common/ISitemapDependencies";
+export type ISeoDependencies = ISearchDependencies | ISitemapDependencies;

package/dist/src/common/ISitemapDependencies.d.ts

@@ -0,0 +1,7 @@
+import { IDependencies } from "../common/IDependencies";
+import { ISearchApiClient } from "../sitemap-generator/ISearchApiClient";
+import { IOrganisationsClient } from "../sitemap-generator/IOrganisationsClient";
+export interface ISitemapDependencies extends IDependencies {
+    searchApiClient: ISearchApiClient;
+    organisationsClient: IOrganisationsClient;
+}

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

@@ -1,6 +1,4 @@
-import { ISeoInfoBase } from "./ISeoInfoBase";
-import { ISeoFilterState } from "./ISeoFilterState";
-import { ISeoFilterOptions } from "./ISeoFilterOptions";
-import { ISeoSearchApplicationState } from "./ISeoSearchApplicationState";
-import { ISearchIndexabilityManager } from "./ISearchIndexabilityManager";
-export { ISeoFilterOptions, ISeoInfoBase, ISeoFilterState, ISeoSearchApplicationState, ISearchIndexabilityManager };
+export * from "./ISeoInfoBase";
+export * from "./ISeoFilterState";
+export * from "./ISearchApplicationState";
+export * from "./ISearchIndexabilityManager";

package/dist/src/common/index.js

@@ -1 +1,4 @@
-export {};
+export * from "./ISeoInfoBase";
+export * from "./ISeoFilterState";
+export * from "./ISearchApplicationState";
+export * from "./ISearchIndexabilityManager";

package/dist/src/common/policies/BaseSeoIndexabilityPolicy.d.ts

@@ -0,0 +1,15 @@
+import { ISitemapUrlGenerator } from "../ISitemapUrlGenerator";
+import { ISeoIndexabilityPolicy } from "../ISeoIndexabilityPolicy";
+import { IDependencies } from "../IDependencies";
+import { FilterCombinations } from "../../enums/FilterCombinations";
+export declare abstract class BaseSeoIndexabilityPolicy<TDependencies extends IDependencies> implements ISeoIndexabilityPolicy, ISitemapUrlGenerator {
+    protected readonly dependencies: TDependencies;
+    constructor(dependencies: TDependencies);
+    shouldIndex(): Promise<boolean>;
+    generateSitemapUrls(): Promise<string[]>;
+    private isIndexabilityPolicyDependencies;
+    private isSitemapUrlGeneratorDependencies;
+    protected abstract isIndexable(): Promise<boolean>;
+    protected abstract generateUrls(): Promise<string[]>;
+    abstract get filterCombination(): FilterCombinations;
+}

package/dist/src/common/{BaseSeoIndexabilityPolicy.js → policies/BaseSeoIndexabilityPolicy.js}

@@ -1,4 +1,5 @@
-import { DependencyTypes } from "../enums/DependencyTypes";
+import { DependencyTypes } from "../../enums/DependencyTypes";
+import { InvalidDependencyTypeError } from "../../errors/InvalidDependencyTypeError";
 export class BaseSeoIndexabilityPolicy {
     dependencies;
     constructor(dependencies) {
@@ -6,13 +7,13 @@ export class BaseSeoIndexabilityPolicy {
     }
     async shouldIndex() {
         if (!this.isIndexabilityPolicyDependencies()) {
-            throw new Error('Dependency type is incorrect.');
+            throw new InvalidDependencyTypeError();
         }
-        return this.matchesFilters();
+        return this.isIndexable();
     }
     async generateSitemapUrls() {
         if (!this.isSitemapUrlGeneratorDependencies()) {
-            throw new Error('Dependency type is incorrect.');
+            throw new InvalidDependencyTypeError();
         }
         return await this.generateUrls();
     }

package/dist/src/common/policies/RuleBasedIndexabilityPolicy.d.ts

@@ -0,0 +1,11 @@
+import { BaseSeoIndexabilityPolicy } from "./BaseSeoIndexabilityPolicy";
+import { ISearchDependencies } from "../ISearchDependencies";
+import { IDependencies } from "../IDependencies";
+import { IRule } from "../IRule";
+import { FilterKeyValuesMap } from "../FilterKeyValuesMap";
+export declare abstract class RuleBasedIndexabilityPolicy<TDependencies extends IDependencies> extends BaseSeoIndexabilityPolicy<TDependencies> {
+    protected abstract readonly rules: IRule[];
+    protected isIndexable(): Promise<boolean>;
+    protected checkRulesForSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    protected checkRulesForSitemap(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

package/dist/src/common/policies/RuleBasedIndexabilityPolicy.js

@@ -0,0 +1,24 @@
+import { BaseSeoIndexabilityPolicy } from "./BaseSeoIndexabilityPolicy";
+export class RuleBasedIndexabilityPolicy extends BaseSeoIndexabilityPolicy {
+    async isIndexable() {
+        return await this.checkRulesForSearch(this.dependencies);
+    }
+    async checkRulesForSearch(dependencies) {
+        for (const rule of this.rules) {
+            const result = await rule.forSearch(dependencies);
+            if (!result) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async checkRulesForSitemap(filterKeyValues) {
+        for (const rule of this.rules) {
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            if (!result) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

package/dist/src/common/rules/BaseFilterKeyValueRule.d.ts

@@ -0,0 +1,10 @@
+import { FilterKeyValuesMap } from "../FilterKeyValuesMap";
+import { IRule } from "../IRule";
+import { ISearchDependencies } from "../ISearchDependencies";
+export declare abstract class BaseFilterKeyValueRule implements IRule {
+    private readonly expectedFilterKeyValues;
+    constructor(expectedFilterKeyValues: FilterKeyValuesMap);
+    abstract getName(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

package/dist/src/common/rules/BaseFilterKeyValueRule.js

@@ -0,0 +1,27 @@
+export class BaseFilterKeyValueRule {
+    expectedFilterKeyValues;
+    constructor(expectedFilterKeyValues) {
+        this.expectedFilterKeyValues = expectedFilterKeyValues;
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const result = Array.from(this.expectedFilterKeyValues)
+            .reduce((acc, [key, values]) => {
+            const optionValue = seoInfoBase.getFilterOptionValueBy(key, filterState);
+            return acc && optionValue === values[0];
+        }, true);
+        return Promise.resolve(result);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        for (const [key, values] of this.expectedFilterKeyValues) {
+            const filterValues = filterKeyValues.get(key);
+            if (!filterValues || filterValues.length !== values.length) {
+                return Promise.resolve(false);
+            }
+            if (!values.every((value) => filterValues.includes(value))) {
+                return Promise.resolve(false);
+            }
+        }
+        return Promise.resolve(true);
+    }
+}

package/dist/src/common/rules/OnlyFiltersSelectedRule.d.ts

@@ -0,0 +1,11 @@
+import { IRule } from "../../common/IRule";
+import { FilterKey } from "@studyportals/search-filters";
+import { ISearchDependencies } from "../../common/ISearchDependencies";
+import { FilterKeyValuesMap } from "../FilterKeyValuesMap";
+export declare class OnlyFiltersSelectedRule implements IRule {
+    private readonly filterKeys;
+    constructor(filterKeys: FilterKey[]);
+    getName(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

package/dist/src/common/rules/OnlyFiltersSelectedRule.js

@@ -0,0 +1,27 @@
+export class OnlyFiltersSelectedRule {
+    filterKeys;
+    constructor(filterKeys) {
+        this.filterKeys = filterKeys;
+    }
+    getName() {
+        return 'OneValueSelectedForFilterRule';
+    }
+    async forSearch(dependencies) {
+        const seoInfoBase = dependencies.seoInfoBase;
+        const filterState = dependencies.filterState;
+        return await seoInfoBase.selectionOnlyFor(this.filterKeys, filterState);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const filterKeys = Array.from(filterKeyValues.keys());
+        if (filterKeys.length !== this.filterKeys.length) {
+            return Promise.resolve(false);
+        }
+        if (!filterKeys.every((filterKey) => this.filterKeys.includes(filterKey))) {
+            return Promise.resolve(false);
+        }
+        if (!this.filterKeys.every((filterKey) => filterKeys.includes(filterKey))) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(true);
+    }
+}

package/dist/src/common/rules/SingleValueSelectedForFilterRule.d.ts

@@ -0,0 +1,11 @@
+import { IRule } from "../../common/IRule";
+import { FilterKey } from "@studyportals/search-filters";
+import { ISearchDependencies } from "../../common/ISearchDependencies";
+import { FilterKeyValuesMap } from "../FilterKeyValuesMap";
+export declare class SingleValueSelectedForFilterRule implements IRule {
+    private readonly filterKey;
+    constructor(filterKey: FilterKey);
+    getName(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

package/dist/src/common/rules/SingleValueSelectedForFilterRule.js

@@ -0,0 +1,21 @@
+export class SingleValueSelectedForFilterRule {
+    filterKey;
+    constructor(filterKey) {
+        this.filterKey = filterKey;
+    }
+    getName() {
+        return 'OneValueSelectedForFilterRule';
+    }
+    async forSearch(dependencies) {
+        const seoInfoBase = dependencies.seoInfoBase;
+        const filterState = dependencies.filterState;
+        return await seoInfoBase.singleSelectionFor(this.filterKey, filterState);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const filterValues = filterKeyValues.get(this.filterKey);
+        if (!filterValues || filterValues.length !== 1) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(true);
+    }
+}

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

@@ -1,9 +1,17 @@
 export declare enum FilterCombinations {
     AREA = "area",
+    AREA_ATTENDANCE = "areaAttendance",
+    AREA_DISCIPLINE = "areaDiscipline",
     COUNTRY = "country",
     DISCIPLINE_AREA = "disciplineArea",
+    DISCIPLINE_ATTENDANCE = "disciplineAttendance",
     DISCIPLINE_COUNTRY = "disciplineCountry",
     DISCIPLINE = "discipline",
     UNFILTERED = "unfiltered",
-    UNIVERSITY_COUNTRY = "universityCountry"
+    UNIVERSITY_COUNTRY = "universityCountry",
+    ATTENDANCE_DISCIPLINE = "attendancedDiscipline",
+    CONTINENT_ATTENDANCE = "continentAttendance",
+    COUNTRY_ATTENDANCE = "countryAttendance",
+    ATTENDANCE = "attendance",
+    CONTINENT = "continent"
 }

package/dist/src/enums/FilterCombinations.js

@@ -1,10 +1,19 @@
 export var FilterCombinations;
 (function (FilterCombinations) {
     FilterCombinations["AREA"] = "area";
+    FilterCombinations["AREA_ATTENDANCE"] = "areaAttendance";
+    FilterCombinations["AREA_DISCIPLINE"] = "areaDiscipline";
     FilterCombinations["COUNTRY"] = "country";
     FilterCombinations["DISCIPLINE_AREA"] = "disciplineArea";
+    FilterCombinations["DISCIPLINE_ATTENDANCE"] = "disciplineAttendance";
     FilterCombinations["DISCIPLINE_COUNTRY"] = "disciplineCountry";
     FilterCombinations["DISCIPLINE"] = "discipline";
     FilterCombinations["UNFILTERED"] = "unfiltered";
     FilterCombinations["UNIVERSITY_COUNTRY"] = "universityCountry";
+    // TODO: orgs
+    FilterCombinations["ATTENDANCE_DISCIPLINE"] = "attendancedDiscipline";
+    FilterCombinations["CONTINENT_ATTENDANCE"] = "continentAttendance";
+    FilterCombinations["COUNTRY_ATTENDANCE"] = "countryAttendance";
+    FilterCombinations["ATTENDANCE"] = "attendance";
+    FilterCombinations["CONTINENT"] = "continent";
 })(FilterCombinations || (FilterCombinations = {}));

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,4 @@
+import { ISearchApplicationState } from "../common";
+export interface IOrganisationSearchApplicationState extends ISearchApplicationState {
+    getRankedResultsCount(): number;
+}

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/OrganisationsBaseSeoIndexabilityPolicy.d.ts

@@ -0,0 +1,11 @@
+import { PortalType } from "@studyportals/domain-client";
+import { IOrganisationsSeoDependencies } from "./types/IOrganisationsSeoDependencies";
+import { BaseSeoIndexabilityPolicy } from "../common/policies/BaseSeoIndexabilityPolicy";
+import { SortingOptions } from "../enums/SortingOptions";
+export declare abstract class OrganisationsBaseSeoIndexabilityPolicy extends BaseSeoIndexabilityPolicy<IOrganisationsSeoDependencies> {
+    protected readonly indexablePortalTypes: PortalType[];
+    protected abstract readonly sortingOption: SortingOptions;
+    constructor(dependencies: IOrganisationsSeoDependencies);
+    shouldIndex(): Promise<boolean>;
+    private matchesSortingOption;
+}

package/dist/src/organisations/OrganisationsBaseSeoIndexabilityPolicy.js

@@ -0,0 +1,20 @@
+import { PortalType } from "@studyportals/domain-client";
+import { BaseSeoIndexabilityPolicy } from "../common/policies/BaseSeoIndexabilityPolicy";
+export class OrganisationsBaseSeoIndexabilityPolicy extends BaseSeoIndexabilityPolicy {
+    indexablePortalTypes = [PortalType.MASTER];
+    constructor(dependencies) {
+        super(dependencies);
+    }
+    async shouldIndex() {
+        const shouldIndex = await super.shouldIndex();
+        if (!shouldIndex) {
+            return false;
+        }
+        return this.indexablePortalTypes.includes(this.dependencies.portalType)
+            && this.matchesSortingOption();
+    }
+    matchesSortingOption() {
+        const dependencies = this.dependencies;
+        return dependencies.sortingState.getSelectedOption() === this.sortingOption;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { PortalType } from "@studyportals/domain-client";
+import { RuleBasedIndexabilityPolicy } from "../common/policies/RuleBasedIndexabilityPolicy";
+import { IOrganisationsSeoDependencies } from "./types/IOrganisationsSeoDependencies";
+import { SortingOptions } from "../enums/SortingOptions";
+export declare abstract class OrganisationsRuleBasedIndexabilityPolicy extends RuleBasedIndexabilityPolicy<IOrganisationsSeoDependencies> {
+    protected readonly indexablePortalTypes: PortalType[];
+    protected abstract readonly sortingOption: SortingOptions;
+    constructor(dependencies: IOrganisationsSeoDependencies);
+    shouldIndex(): Promise<boolean>;
+    private matchesSortingOption;
+}

package/dist/src/organisations/OrganisationsRuleBasedIndexabilityPolicy.js

@@ -0,0 +1,20 @@
+import { PortalType } from "@studyportals/domain-client";
+import { RuleBasedIndexabilityPolicy } from "../common/policies/RuleBasedIndexabilityPolicy";
+export class OrganisationsRuleBasedIndexabilityPolicy extends RuleBasedIndexabilityPolicy {
+    indexablePortalTypes = [PortalType.MASTER];
+    constructor(dependencies) {
+        super(dependencies);
+    }
+    async shouldIndex() {
+        const shouldIndex = await super.shouldIndex();
+        if (!shouldIndex) {
+            return false;
+        }
+        return this.indexablePortalTypes.includes(this.dependencies.portalType)
+            && this.matchesSortingOption();
+    }
+    matchesSortingOption() {
+        const dependencies = this.dependencies;
+        return dependencies.sortingState.getSelectedOption() === this.sortingOption;
+    }
+}

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

@@ -1,6 +1,11 @@
 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>;
 }

package/dist/src/organisations/SearchIndexabilityManager.js

@@ -1,6 +1,39 @@
+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 = [];
-    shouldIndex() {
-        throw new Error("Method not implemented.");
+    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);
     }
 }

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

@@ -1 +1,4 @@
-"use strict";
+export * from "./IOrganisationSearchApplicationState";
+export * from "./ISeoSortingState";
+export * from "./SearchIndexabilityManager";
+export * from "./types";

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,11 @@
+import { FilterCombinations } from "../../../enums/FilterCombinations";
+import { SortingOptions } from "../../../enums/SortingOptions";
+import { SingleValueSelectedForFilterRule } from "../../../common/rules/SingleValueSelectedForFilterRule";
+import { OrganisationsRuleBasedIndexabilityPolicy } from "../../../organisations/OrganisationsRuleBasedIndexabilityPolicy";
+import { OnlyFiltersSelectedRule } from "../../../common/rules/OnlyFiltersSelectedRule";
+export declare class Area extends OrganisationsRuleBasedIndexabilityPolicy {
+    protected readonly sortingOption = SortingOptions.OUR_PICKS;
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

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

@@ -0,0 +1,20 @@
+import { FilterCombinations } from "../../../enums/FilterCombinations";
+import { FilterKey } from "@studyportals/search-filters";
+import { SortingOptions } from "../../../enums/SortingOptions";
+import { SingleValueSelectedForFilterRule } from "../../../common/rules/SingleValueSelectedForFilterRule";
+import { OrganisationsRuleBasedIndexabilityPolicy } from "../../../organisations/OrganisationsRuleBasedIndexabilityPolicy";
+import { OnlyFiltersSelectedRule } from "../../../common/rules/OnlyFiltersSelectedRule";
+export class Area extends OrganisationsRuleBasedIndexabilityPolicy {
+    sortingOption = SortingOptions.OUR_PICKS;
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.AREA),
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY])
+    ];
+    async generateUrls() {
+        return [];
+    }
+    get filterCombination() {
+        return FilterCombinations.AREA;
+    }
+}

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

@@ -0,0 +1,13 @@
+import { OrganisationsRuleBasedIndexabilityPolicy } from "../../../organisations/OrganisationsRuleBasedIndexabilityPolicy";
+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 "../../../organisations/rules/OnlineAttendanceRule";
+export declare class AreaAttendance extends OrganisationsRuleBasedIndexabilityPolicy {
+    protected readonly sortingOption = SortingOptions.OUR_PICKS;
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | SearchVolumeAreasAttendanceRule | OnlineAttendanceRule)[];
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

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

@@ -0,0 +1,25 @@
+import { OrganisationsRuleBasedIndexabilityPolicy } from "../../../organisations/OrganisationsRuleBasedIndexabilityPolicy";
+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 "../../../organisations/rules/OnlineAttendanceRule";
+export class AreaAttendance extends OrganisationsRuleBasedIndexabilityPolicy {
+    sortingOption = SortingOptions.OUR_PICKS;
+    rules = [
+        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() {
+        return [];
+    }
+    get filterCombination() {
+        return FilterCombinations.AREA_ATTENDANCE;
+    }
+}