@studyportals/static-domain-data 7.0.0-3 → 7.0.0-5

package/esm/src/areas/chunks/areas-82.js

@@ -0,0 +1,54 @@
+const areaRecords = [
+    ["3578", "Arkansas", "82"],
+    ["3579", "Washington, D.C.", "82"],
+    ["3580", "Delaware", "82"],
+    ["3581", "Florida", "82"],
+    ["3582", "Georgia", "82"],
+    ["3583", "Kansas", "82"],
+    ["3584", "Louisiana", "82"],
+    ["3585", "Maryland", "82"],
+    ["3586", "Missouri", "82"],
+    ["3587", "Mississippi", "82"],
+    ["3588", "North Carolina", "82"],
+    ["3589", "Oklahoma", "82"],
+    ["3590", "South Carolina", "82"],
+    ["3591", "Tennessee", "82"],
+    ["3592", "Texas", "82"],
+    ["3593", "West Virginia", "82"],
+    ["3594", "Alabama", "82"],
+    ["3595", "Connecticut", "82"],
+    ["3596", "Iowa", "82"],
+    ["3597", "Illinois", "82"],
+    ["3598", "Indiana", "82"],
+    ["3599", "Maine", "82"],
+    ["3600", "Michigan", "82"],
+    ["3601", "Minnesota", "82"],
+    ["3602", "Nebraska", "82"],
+    ["3603", "New Hampshire", "82"],
+    ["3604", "New Jersey", "82"],
+    ["3605", "New York", "82"],
+    ["3606", "Ohio", "82"],
+    ["3607", "Rhode Island", "82"],
+    ["3608", "Vermont", "82"],
+    ["3609", "Wisconsin", "82"],
+    ["3610", "California", "82"],
+    ["3611", "Colorado", "82"],
+    ["3612", "New Mexico", "82"],
+    ["3613", "Nevada", "82"],
+    ["3614", "Utah", "82"],
+    ["3615", "Arizona", "82"],
+    ["3616", "Idaho", "82"],
+    ["3617", "Montana", "82"],
+    ["3618", "North Dakota", "82"],
+    ["3619", "Oregon", "82"],
+    ["3620", "South Dakota", "82"],
+    ["3621", "Washington", "82"],
+    ["3622", "Wyoming", "82"],
+    ["3623", "Hawaii", "82"],
+    ["3624", "Alaska", "82"],
+    ["3625", "Kentucky", "82"],
+    ["3626", "Massachusetts", "82"],
+    ["3627", "Pennsylvania", "82"],
+    ["3628", "Virginia", "82"],
+];
+export { areaRecords, };

package/esm/src/areas/i-area-record.d.ts

@@ -0,0 +1 @@
+export type IAreaRecord = readonly [id: string, name: string, countryId: string];

package/esm/src/areas/i-area-record.js

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

package/esm/src/countries/country-get-async.d.ts

@@ -1,4 +1,7 @@
-import { ICountry } from "./i-country";
+import type { ICountry } from "./i-country";
+import type { ICountryExtended } from "./i-country-extended";
 declare const countryGetByIdAsync: (id: string) => Promise<ICountry | null>;
 declare const countryGetByIsoCodeAsync: (isoCode: string) => Promise<ICountry | null>;
-export { countryGetByIdAsync, countryGetByIsoCodeAsync, };
+declare const countryGetExtendedByIdAsync: (id: string) => Promise<ICountryExtended | null>;
+declare const countryGetExtendedByIsoCodeAsync: (isoCode: string) => Promise<ICountryExtended | null>;
+export { countryGetByIdAsync, countryGetByIsoCodeAsync, countryGetExtendedByIdAsync, countryGetExtendedByIsoCodeAsync, };

package/esm/src/countries/country-get-async.js

@@ -7,11 +7,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { countryIdChunkMapping } from "./country-id-chunk-mapping.js";
-import { countryIsoChunkMapping } from "./country-iso-chunk-mapping.js";
+import { countryGetIsoCode } from "./country-get-iso-code.js";
 const countriesByChunkCache = new Map();
 const countryByIdCache = new Map();
 const countryByIsoCodeCache = new Map();
+const countryExtendedByIdCache = new Map();
+const countryExtendedByIsoCodeCache = new Map();
 const countryChunkLoaders = {
     "a-f": () => import("./chunks/country-records-a-f.js"),
     "g-l": () => import("./chunks/country-records-g-l.js"),
@@ -31,6 +32,22 @@ const getRecordsFromChunkModule = (chunk, chunkModule) => {
             return (_d = chunkModule.countryRecordsSZ) !== null && _d !== void 0 ? _d : [];
     }
 };
+const countryGetChunkByIsoCode = (isoCode) => {
+    const firstLetter = isoCode[0];
+    if (!firstLetter) {
+        return null;
+    }
+    if (firstLetter >= "A" && firstLetter <= "F") {
+        return "a-f";
+    }
+    if (firstLetter >= "G" && firstLetter <= "L") {
+        return "g-l";
+    }
+    if (firstLetter >= "M" && firstLetter <= "R") {
+        return "m-r";
+    }
+    return "s-z";
+};
 const loadCountryChunk = (chunk) => __awaiter(void 0, void 0, void 0, function* () {
     if (countriesByChunkCache.has(chunk)) {
         return countriesByChunkCache.get(chunk);
@@ -41,6 +58,9 @@ const loadCountryChunk = (chunk) => __awaiter(void 0, void 0, void 0, function*
         const country = { id, name };
         countryByIdCache.set(id, country);
         countryByIsoCodeCache.set(isoCode, country);
+        const countryExtended = Object.assign(Object.assign({}, country), { iso: isoCode });
+        countryExtendedByIdCache.set(id, countryExtended);
+        countryExtendedByIsoCodeCache.set(isoCode, countryExtended);
         return country;
     });
     countriesByChunkCache.set(chunk, countries);
@@ -52,7 +72,8 @@ const countryGetByIdAsync = (id) => __awaiter(void 0, void 0, void 0, function*
     if (countryByIdCache.has(normalizedId)) {
         return countryByIdCache.get(normalizedId);
     }
-    const chunk = countryIdChunkMapping[normalizedId];
+    const isoCode = countryGetIsoCode(normalizedId);
+    const chunk = isoCode ? countryGetChunkByIsoCode(isoCode) : null;
     if (!chunk) {
         return null;
     }
@@ -65,11 +86,43 @@ const countryGetByIsoCodeAsync = (isoCode) => __awaiter(void 0, void 0, void 0,
     if (countryByIsoCodeCache.has(normalizedIsoCode)) {
         return countryByIsoCodeCache.get(normalizedIsoCode);
     }
-    const chunk = countryIsoChunkMapping[normalizedIsoCode];
+    const chunk = countryGetChunkByIsoCode(normalizedIsoCode);
     if (!chunk) {
         return null;
     }
     yield loadCountryChunk(chunk);
     return (_a = countryByIsoCodeCache.get(normalizedIsoCode)) !== null && _a !== void 0 ? _a : null;
 });
-export { countryGetByIdAsync, countryGetByIsoCodeAsync, };
+const countryGetExtendedByIdAsync = (id) => __awaiter(void 0, void 0, void 0, function* () {
+    const normalizedId = id.trim();
+    if (countryExtendedByIdCache.has(normalizedId)) {
+        return countryExtendedByIdCache.get(normalizedId);
+    }
+    const country = yield countryGetByIdAsync(normalizedId);
+    if (!country) {
+        return null;
+    }
+    const isoCode = countryGetIsoCode(normalizedId);
+    if (!isoCode) {
+        return null;
+    }
+    const countryExtended = Object.assign(Object.assign({}, country), { iso: isoCode });
+    countryExtendedByIdCache.set(normalizedId, countryExtended);
+    countryExtendedByIsoCodeCache.set(isoCode, countryExtended);
+    return countryExtended;
+});
+const countryGetExtendedByIsoCodeAsync = (isoCode) => __awaiter(void 0, void 0, void 0, function* () {
+    const normalizedIsoCode = isoCode.toUpperCase().trim();
+    if (countryExtendedByIsoCodeCache.has(normalizedIsoCode)) {
+        return countryExtendedByIsoCodeCache.get(normalizedIsoCode);
+    }
+    const country = yield countryGetByIsoCodeAsync(normalizedIsoCode);
+    if (!country) {
+        return null;
+    }
+    const countryExtended = Object.assign(Object.assign({}, country), { iso: normalizedIsoCode });
+    countryExtendedByIsoCodeCache.set(normalizedIsoCode, countryExtended);
+    countryExtendedByIdCache.set(country.id, countryExtended);
+    return countryExtended;
+});
+export { countryGetByIdAsync, countryGetByIsoCodeAsync, countryGetExtendedByIdAsync, countryGetExtendedByIsoCodeAsync, };

package/esm/src/currencies/currency-get-countries-async.d.ts

@@ -0,0 +1,2 @@
+declare const currencyGetCountriesAsync: (iso: string) => Promise<readonly string[]>;
+export { currencyGetCountriesAsync, };

package/esm/src/currencies/currency-get-countries-async.js

@@ -0,0 +1,31 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { countryGetByIsoCodeAsync } from "../countries/country-get-async.js";
+import { currencyIsoCountryIsoMapping } from "./currency-iso-country-iso-mapping.js";
+const countryIsoCodesByCurrencyIso = new Map();
+for (const { countryIso, currencyIso } of currencyIsoCountryIsoMapping) {
+    if (countryIsoCodesByCurrencyIso.has(currencyIso)) {
+        countryIsoCodesByCurrencyIso.get(currencyIso).push(countryIso);
+    }
+    else {
+        countryIsoCodesByCurrencyIso.set(currencyIso, [countryIso]);
+    }
+}
+const currencyGetCountriesAsync = (iso) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const normalizedIso = iso.toUpperCase().trim();
+    const countryIsoCodes = (_a = countryIsoCodesByCurrencyIso.get(normalizedIso)) !== null && _a !== void 0 ? _a : [];
+    if (!countryIsoCodes.length) {
+        return [];
+    }
+    const countries = yield Promise.all(countryIsoCodes.map((countryIsoCode) => countryGetByIsoCodeAsync(countryIsoCode)));
+    return countries.flatMap((country) => (country ? [country.id] : []));
+});
+export { currencyGetCountriesAsync, };

package/esm/src/currencies/currency-get-from-country-async.d.ts

@@ -0,0 +1,3 @@
+import type { ICurrency } from "./i-currency";
+declare const currencyGetFromCountryAsync: (countryIso: string) => Promise<ICurrency | undefined>;
+export { currencyGetFromCountryAsync, };

package/esm/src/currencies/currency-get-from-country-async.js

@@ -0,0 +1,19 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { currencyIsoCountryIsoMapping } from "./currency-iso-country-iso-mapping.js";
+import { currencyGetByIsoAsync } from "./currency-get-async.js";
+const currencyIsoByCountryIso = new Map(currencyIsoCountryIsoMapping.map(({ countryIso, currencyIso }) => [countryIso, currencyIso]));
+const currencyGetFromCountryAsync = (countryIso) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const normalizedCountryIso = countryIso.toUpperCase().trim();
+    const currencyIso = (_a = currencyIsoByCountryIso.get(normalizedCountryIso)) !== null && _a !== void 0 ? _a : "EUR";
+    return (_b = (yield currencyGetByIsoAsync(currencyIso))) !== null && _b !== void 0 ? _b : undefined;
+});
+export { currencyGetFromCountryAsync, };

package/esm/src/disciplines/discipline-get-parent-discipline-async.d.ts

@@ -0,0 +1,2 @@
+declare const subdisciplineGetParentIdAsync: (subDisciplineId: string) => Promise<string | null>;
+export { subdisciplineGetParentIdAsync, };

package/esm/src/disciplines/discipline-get-parent-discipline-async.js

@@ -0,0 +1,14 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { subdisciplineIdDisciplineIdMapping } from "./subdiscipline-id-discipline-id-mapping.js";
+const subdisciplineGetParentIdAsync = (subDisciplineId) => __awaiter(void 0, void 0, void 0, function* () {
+    return subdisciplineIdDisciplineIdMapping[subDisciplineId] || null;
+});
+export { subdisciplineGetParentIdAsync, };

package/esm/src/disciplines/discipline-get-sub-or-parent-discipline-async.d.ts

@@ -0,0 +1,4 @@
+import type { IDiscipline } from "./i-discipline";
+import type { ISubDiscipline } from "./i-sub-discipline";
+declare const disciplineGetSubOrParentDisciplineAsync: (id: string) => Promise<ISubDiscipline | IDiscipline | undefined>;
+export { disciplineGetSubOrParentDisciplineAsync, };

package/esm/src/disciplines/discipline-get-sub-or-parent-discipline-async.js

@@ -0,0 +1,19 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { disciplineGetSubdisciplineByIdAsync } from "./discipline-get-subdiscipline-by-id-async.js";
+import { disciplinesAll } from "./disciplines.js";
+const disciplineGetSubOrParentDisciplineAsync = (id) => __awaiter(void 0, void 0, void 0, function* () {
+    const subDiscipline = yield disciplineGetSubdisciplineByIdAsync(id);
+    if (subDiscipline) {
+        return subDiscipline;
+    }
+    return disciplinesAll.find((discipline) => discipline.id === id);
+});
+export { disciplineGetSubOrParentDisciplineAsync, };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@studyportals/static-domain-data",
-	"version": "7.0.0-3",
+	"version": "7.0.0-5",
 	"sideEffects": false,
 	"exports": {
 		"./*": {

package/cjs/src/countries/country-id-chunk-mapping.js

@@ -1,235 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.countryIdChunkMapping = void 0;
-const countryIdChunkMapping = {
-    "1": "m-r",
-    "2": "a-f",
-    "3": "a-f",
-    "4": "a-f",
-    "5": "a-f",
-    "6": "a-f",
-    "7": "a-f",
-    "8": "a-f",
-    "9": "a-f",
-    "10": "a-f",
-    "11": "g-l",
-    "12": "g-l",
-    "13": "g-l",
-    "14": "g-l",
-    "15": "g-l",
-    "16": "g-l",
-    "17": "g-l",
-    "18": "m-r",
-    "19": "m-r",
-    "20": "m-r",
-    "21": "m-r",
-    "22": "m-r",
-    "23": "s-z",
-    "24": "s-z",
-    "25": "g-l",
-    "26": "s-z",
-    "27": "s-z",
-    "28": "s-z",
-    "29": "s-z",
-    "30": "s-z",
-    "31": "s-z",
-    "33": "m-r",
-    "34": "g-l",
-    "35": "m-r",
-    "36": "m-r",
-    "37": "m-r",
-    "38": "a-f",
-    "39": "m-r",
-    "40": "a-f",
-    "41": "s-z",
-    "42": "a-f",
-    "43": "g-l",
-    "44": "a-f",
-    "45": "a-f",
-    "46": "a-f",
-    "47": "g-l",
-    "48": "s-z",
-    "49": "a-f",
-    "50": "a-f",
-    "51": "a-f",
-    "52": "a-f",
-    "53": "a-f",
-    "54": "a-f",
-    "55": "a-f",
-    "56": "a-f",
-    "57": "a-f",
-    "58": "a-f",
-    "59": "a-f",
-    "60": "a-f",
-    "61": "a-f",
-    "62": "a-f",
-    "63": "g-l",
-    "64": "g-l",
-    "65": "g-l",
-    "66": "g-l",
-    "67": "g-l",
-    "68": "g-l",
-    "69": "g-l",
-    "70": "m-r",
-    "71": "m-r",
-    "72": "m-r",
-    "74": "m-r",
-    "75": "m-r",
-    "76": "m-r",
-    "77": "s-z",
-    "78": "s-z",
-    "79": "s-z",
-    "80": "s-z",
-    "81": "s-z",
-    "82": "s-z",
-    "83": "s-z",
-    "84": "a-f",
-    "85": "a-f",
-    "86": "a-f",
-    "87": "a-f",
-    "88": "a-f",
-    "89": "a-f",
-    "90": "a-f",
-    "91": "g-l",
-    "92": "m-r",
-    "93": "m-r",
-    "94": "s-z",
-    "95": "s-z",
-    "96": "s-z",
-    "97": "a-f",
-    "98": "a-f",
-    "99": "a-f",
-    "100": "a-f",
-    "101": "a-f",
-    "102": "a-f",
-    "103": "a-f",
-    "104": "a-f",
-    "105": "a-f",
-    "106": "g-l",
-    "107": "g-l",
-    "108": "g-l",
-    "109": "g-l",
-    "110": "g-l",
-    "111": "g-l",
-    "112": "g-l",
-    "113": "g-l",
-    "114": "g-l",
-    "115": "g-l",
-    "116": "m-r",
-    "117": "s-z",
-    "118": "g-l",
-    "119": "g-l",
-    "120": "g-l",
-    "121": "g-l",
-    "122": "m-r",
-    "123": "m-r",
-    "124": "m-r",
-    "125": "m-r",
-    "126": "m-r",
-    "127": "m-r",
-    "128": "m-r",
-    "129": "m-r",
-    "130": "m-r",
-    "131": "m-r",
-    "132": "s-z",
-    "133": "s-z",
-    "134": "s-z",
-    "135": "s-z",
-    "136": "s-z",
-    "137": "s-z",
-    "138": "s-z",
-    "139": "s-z",
-    "140": "s-z",
-    "141": "s-z",
-    "142": "s-z",
-    "143": "s-z",
-    "144": "m-r",
-    "145": "a-f",
-    "146": "a-f",
-    "147": "a-f",
-    "148": "a-f",
-    "149": "a-f",
-    "150": "a-f",
-    "151": "a-f",
-    "152": "a-f",
-    "153": "a-f",
-    "154": "a-f",
-    "155": "a-f",
-    "156": "a-f",
-    "157": "a-f",
-    "158": "a-f",
-    "159": "a-f",
-    "160": "s-z",
-    "161": "a-f",
-    "162": "a-f",
-    "163": "a-f",
-    "164": "a-f",
-    "165": "g-l",
-    "166": "g-l",
-    "167": "g-l",
-    "168": "g-l",
-    "169": "g-l",
-    "170": "g-l",
-    "171": "g-l",
-    "172": "g-l",
-    "173": "g-l",
-    "174": "m-r",
-    "175": "m-r",
-    "176": "m-r",
-    "177": "m-r",
-    "178": "m-r",
-    "179": "m-r",
-    "180": "m-r",
-    "181": "m-r",
-    "182": "m-r",
-    "183": "m-r",
-    "184": "m-r",
-    "185": "m-r",
-    "186": "s-z",
-    "187": "s-z",
-    "188": "s-z",
-    "189": "s-z",
-    "190": "s-z",
-    "191": "s-z",
-    "192": "s-z",
-    "193": "a-f",
-    "194": "s-z",
-    "195": "s-z",
-    "196": "s-z",
-    "197": "s-z",
-    "198": "s-z",
-    "199": "s-z",
-    "200": "s-z",
-    "201": "a-f",
-    "202": "a-f",
-    "203": "a-f",
-    "204": "a-f",
-    "205": "a-f",
-    "206": "g-l",
-    "207": "g-l",
-    "208": "m-r",
-    "209": "m-r",
-    "210": "m-r",
-    "211": "m-r",
-    "212": "m-r",
-    "213": "m-r",
-    "214": "m-r",
-    "215": "m-r",
-    "216": "m-r",
-    "217": "s-z",
-    "218": "s-z",
-    "219": "s-z",
-    "220": "s-z",
-    "221": "s-z",
-    "222": "s-z",
-    "223": "s-z",
-    "224": "a-f",
-    "225": "a-f",
-    "226": "s-z",
-    "227": "a-f",
-    "229": "m-r",
-    "230": "g-l",
-    "232": "s-z",
-    "233": "a-f",
-};
-exports.countryIdChunkMapping = countryIdChunkMapping;