@wise-old-man/utils 1.0.25 → 2.0.0-beta.0

package/package.json

@@ -1,29 +1,27 @@
 {
   "name": "@wise-old-man/utils",
-  "version": "1.0.25",
-  "description": "A few constants and helper functions to be re-used in all repositories under the WiseOldMan project.",
-  "main": "dist/lib/index.js",
-  "types": "dist/lib/index.d.ts",
-  "files": [
-    "dist/lib"
-  ],
+  "version": "2.0.0-beta.0",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "prepublish": "tsc",
-    "build": "tsc",
-    "test": "jest"
+    "prepublish": "npm run build",
+    "prebuild": "cd ../server && npm run prisma:generate",
+    "build": "rm -rf ./dist && npx rollup -c && node prisma-transform.js"
   },
   "keywords": [],
   "author": "",
   "license": "ISC",
   "devDependencies": {
-    "@types/jest": "^27.0.3",
-    "@types/lodash": "^4.14.177",
-    "jest": "^27.4.5",
-    "ts-jest": "^27.1.2",
-    "ts-node": "^10.4.0",
-    "typescript": "^4.4.3"
+    "@rollup/plugin-typescript": "^8.3.4",
+    "rollup": "^2.78.0",
+    "rollup-plugin-dts": "^4.2.2",
+    "tslib": "^2.4.0",
+    "typescript": "^4.7.4"
   },
   "dependencies": {
+    "axios": "^0.27.2",
+    "dayjs": "^1.11.5",
     "lodash": "^4.17.21"
   }
 }

package/prisma-transform.js

@@ -0,0 +1,35 @@
+/**
+ * This is an extremely hacky script that mashes up some of Prisma's type declarations with my own.
+ * I can't simply bundle up all type declarations with rollup because the dts plugin doesn't support namespaces.
+ */
+
+const fs = require('fs');
+
+const PRIVATE_MODEL_NAMES = ['Achievement', 'Record', 'Delta', 'Snapshot', 'Player'];
+
+const START_TOKEN = 'export type Achievement';
+const END_TOKEN = ' * Enums';
+
+const PRISMA_DECLARATION_FILE_PATH = '../server/node_modules/.prisma/client/index.d.ts';
+const BUILD_DECLARATION_FILE_PATH = './dist/index.d.ts';
+
+const buildContent = fs.readFileSync(BUILD_DECLARATION_FILE_PATH, { encoding: 'utf8' });
+const parsedBuildContent = buildContent.split('\n').splice(2).join('\n');
+
+const prismaContent = fs.readFileSync(PRISMA_DECLARATION_FILE_PATH, { encoding: 'utf8' });
+const parsedPrismaContent = prismaContent
+  .substring(prismaContent.indexOf(START_TOKEN), prismaContent.indexOf(END_TOKEN))
+  .replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '')
+  .replace('/**', '')
+  .split('\n')
+  .map(line => {
+    const privateModelMatch = PRIVATE_MODEL_NAMES.find(model => line.includes(`export type ${model} =`));
+
+    if (privateModelMatch) return line.replace(privateModelMatch, `${privateModelMatch}$1`);
+    return line;
+  })
+  .join('\n');
+
+const finalContent = `${parsedPrismaContent}\n${parsedBuildContent}`;
+
+fs.writeFileSync(BUILD_DECLARATION_FILE_PATH, finalContent);

package/rollup.config.js

@@ -0,0 +1,24 @@
+import dts from 'rollup-plugin-dts';
+import typescript from '@rollup/plugin-typescript';
+
+export default [
+  {
+    input: 'src/index.ts',
+    output: {
+      dir: 'dist',
+      format: 'cjs',
+      external: ['axios', 'dayjs', 'lodash'],
+      sourcemap: false
+    },
+    plugins: [
+      typescript({
+        tsconfig: './tsconfig.json'
+      })
+    ]
+  },
+  {
+    input: 'src/index.ts',
+    output: [{ file: 'dist/index.d.ts', format: 'cjs' }],
+    plugins: [dts()]
+  }
+];

package/src/client.ts

@@ -0,0 +1,18 @@
+import PlayersClient from './clients/PlayersClient';
+import RecordsClient from './clients/RecordsClient';
+import DeltasClient from './clients/DeltasClient';
+import EfficiencyClient from './clients/EfficiencyClient';
+
+export default class WOMClient {
+  public players: PlayersClient;
+  public records: RecordsClient;
+  public deltas: DeltasClient;
+  public efficiency: EfficiencyClient;
+
+  constructor() {
+    this.players = new PlayersClient();
+    this.records = new RecordsClient();
+    this.deltas = new DeltasClient();
+    this.efficiency = new EfficiencyClient();
+  }
+}

package/src/clients/DeltasClient.ts

@@ -0,0 +1,23 @@
+import { Country, Metric, Period, Player, PlayerBuild, PlayerType } from '../../../server/src/utils';
+import { sendGetRequest } from '../utils';
+
+export interface DeltaLeaderboardFilter {
+  metric: Metric;
+  period: Period | string;
+  country?: Country;
+  playerType?: PlayerType;
+  playerBuild?: PlayerBuild;
+}
+
+export type GetDeltaLeaderboardResponse = Array<{
+  startDate: Date;
+  endDate: Date;
+  gained: number;
+  player: Player;
+}>;
+
+export default class DeltasClient {
+  getDeltaLeaderboard(filter: DeltaLeaderboardFilter) {
+    return sendGetRequest<GetDeltaLeaderboardResponse>('/deltas/leaderboard', filter);
+  }
+}

package/src/clients/EfficiencyClient.ts

@@ -0,0 +1,37 @@
+import {
+  Player,
+  Metric,
+  Country,
+  PlayerType,
+  PlayerBuild,
+  EfficiencyAlgorithmType,
+  SkillMetaConfig,
+  BossMetaConfig
+} from '../../../server/src/utils';
+import { PaginationOptions, sendGetRequest } from '../utils';
+
+export interface EfficiencyLeaderboardsFilter {
+  metric: typeof Metric.EHP | typeof Metric.EHB | 'ehp+ehb';
+  country?: Country;
+  playerType?: PlayerType;
+  playerBuild?: PlayerBuild;
+}
+
+export type GetEfficiencyLeaderboardsResponse = Player[];
+
+export default class EfficiencyClient {
+  getEfficiencyLeaderboards(filter: EfficiencyLeaderboardsFilter, pagination?: PaginationOptions) {
+    return sendGetRequest<GetEfficiencyLeaderboardsResponse>('/efficiency/leaderboard', {
+      ...filter,
+      ...pagination
+    });
+  }
+
+  getEHPRates(algorithmType: `${EfficiencyAlgorithmType}`) {
+    return sendGetRequest<SkillMetaConfig>('/efficiency/rates', { metric: Metric.EHP, type: algorithmType });
+  }
+
+  getEHBRates(algorithmType: `${EfficiencyAlgorithmType}`) {
+    return sendGetRequest<BossMetaConfig[]>('/efficiency/rates', { metric: Metric.EHB, type: algorithmType });
+  }
+}

package/src/clients/PlayersClient.ts

@@ -0,0 +1,136 @@
+import {
+  AchievementProgress,
+  ExtendedAchievement,
+  FormattedSnapshot,
+  MembershipWithGroup,
+  Metric,
+  Record,
+  NameChange,
+  ParticipationWithCompetition,
+  Period,
+  Player,
+  PlayerDeltasArray,
+  PlayerDeltasMap,
+  PlayerDetails,
+  PlayerResolvable
+} from '../../../server/src/utils';
+import { PaginationOptions, sendGetRequest, sendPostRequest } from '../utils';
+
+export type TimeRangeFilter =
+  | {
+      period: Period | string;
+    }
+  | {
+      startDate: Date;
+      endDate: Date;
+    };
+
+export interface PlayerRecordsFilter {
+  period: Period | string;
+  metric: Metric;
+}
+
+export interface AssertPlayerTypeResponse {
+  player: Player;
+  changed: boolean;
+}
+
+export interface ImportPlayerResponse {
+  count: number;
+  message: string;
+}
+
+export type SearchPlayersResponse = Player[];
+export type UpdatePlayerResponse = PlayerDetails;
+export type GetPlayerDetailsResponse = PlayerDetails;
+export type GetPlayerAchievementsResponse = ExtendedAchievement[];
+export type GetPlayerAchievementProgressResponse = AchievementProgress[];
+export type GetPlayerCompetitionsResponse = ParticipationWithCompetition[];
+export type GetPlayerGroupsResponse = MembershipWithGroup[];
+export type GetPlayerRecordsResponse = Record[];
+export type GetPlayerNamesResponse = NameChange[];
+export type GetPlayerSnapshotsResponse = FormattedSnapshot[];
+
+export type GetPlayerGainsResponse<T extends PlayerDeltasArray | PlayerDeltasMap> = {
+  startsAt: Date;
+  endsAt: Date;
+  data: T;
+};
+
+function getPlayerURL(player: PlayerResolvable) {
+  if (typeof player === 'string') {
+    return `/players/${player}`;
+  }
+
+  if (player.id) {
+    return `/players/id/${player.id}`;
+  }
+
+  return `/players/${player.username}`;
+}
+
+export default class PlayersClient {
+  searchPlayers(partialUsername: string, pagination?: PaginationOptions) {
+    return sendGetRequest<SearchPlayersResponse>('/players/search', {
+      username: partialUsername,
+      ...pagination
+    });
+  }
+
+  updatePlayer(player: PlayerResolvable) {
+    return sendPostRequest<UpdatePlayerResponse>(getPlayerURL(player));
+  }
+
+  assertPlayerType(player: PlayerResolvable) {
+    return sendPostRequest<AssertPlayerTypeResponse>(`${getPlayerURL(player)}/assert-type`);
+  }
+
+  importPlayer(player: PlayerResolvable) {
+    return sendPostRequest<ImportPlayerResponse>(`${getPlayerURL(player)}/import-history`);
+  }
+
+  getPlayerDetails(player: PlayerResolvable) {
+    return sendGetRequest<GetPlayerDetailsResponse>(getPlayerURL(player));
+  }
+
+  getPlayerAchievements(player: PlayerResolvable) {
+    return sendGetRequest<GetPlayerAchievementsResponse>(`${getPlayerURL(player)}/achievements`);
+  }
+
+  getPlayerAchievementProgress(player: PlayerResolvable) {
+    return sendGetRequest<GetPlayerAchievementProgressResponse>(
+      `${getPlayerURL(player)}/achievements/progress`
+    );
+  }
+
+  getPlayerCompetitions(player: PlayerResolvable, pagination?: PaginationOptions) {
+    return sendGetRequest<GetPlayerCompetitionsResponse>(`${getPlayerURL(player)}/competitions`, pagination);
+  }
+
+  getPlayerGroups(player: PlayerResolvable, pagination?: PaginationOptions) {
+    return sendGetRequest<GetPlayerGroupsResponse>(`${getPlayerURL(player)}/groups`, pagination);
+  }
+
+  getPlayerGains(player: PlayerResolvable, options: TimeRangeFilter) {
+    return sendGetRequest<GetPlayerGainsResponse<PlayerDeltasMap>>(`${getPlayerURL(player)}/gained`, options);
+  }
+
+  getPlayerGainsAsArray(player: PlayerResolvable, options: TimeRangeFilter) {
+    return sendGetRequest<GetPlayerGainsResponse<PlayerDeltasArray>>(`${getPlayerURL(player)}/gained`, {
+      ...options,
+      formatting: 'array'
+    });
+  }
+
+  getPlayerRecords(player: PlayerResolvable, options?: PlayerRecordsFilter) {
+    return sendGetRequest<GetPlayerRecordsResponse>(`${getPlayerURL(player)}/records`, options);
+  }
+
+  getPlayerSnapshots(player: PlayerResolvable, options?: TimeRangeFilter) {
+    return sendGetRequest<GetPlayerSnapshotsResponse>(`${getPlayerURL(player)}/snapshots`, options);
+  }
+
+  getPlayerNames(player: PlayerResolvable) {
+    return sendGetRequest<GetPlayerNamesResponse>(`${getPlayerURL(player)}/names`);
+  }
+}

package/src/clients/RecordsClient.ts

@@ -0,0 +1,18 @@
+import { Country, Metric, Record, Period, Player, PlayerBuild, PlayerType } from '../../../server/src/utils';
+import { sendGetRequest } from '../utils';
+
+export interface RecordLeaderboardFilter {
+  metric: Metric;
+  period: Period | string;
+  country?: Country;
+  playerType?: PlayerType;
+  playerBuild?: PlayerBuild;
+}
+
+export type GetRecordLeaderboardResponse = Array<Record & { player: Player }>;
+
+export default class RecordsClient {
+  getRecordLeaderboard(filter: RecordLeaderboardFilter) {
+    return sendGetRequest<GetRecordLeaderboardResponse>('/records/leaderboard', filter);
+  }
+}

package/src/config.ts

@@ -0,0 +1,4 @@
+export default {
+  // apiBaseUrl: 'http://localhost:5001'
+  apiBaseUrl: 'https://api.wiseoldman.net/v2'
+};

package/src/index.ts

@@ -0,0 +1,10 @@
+import WOMClient from './client';
+
+export * from '../../server/src/utils';
+
+export * from './clients/PlayersClient';
+export * from './clients/RecordsClient';
+export * from './clients/DeltasClient';
+export * from './clients/EfficiencyClient';
+
+export { WOMClient };

package/src/sandbox.ts

@@ -0,0 +1,26 @@
+import { Country, GetRecordLeaderboardResponse, Metric, Period, RecordLeaderboardFilter, WOMClient } from '.';
+
+async function run() {
+  try {
+    const womClient = new WOMClient();
+
+    console.log(await womClient.players.searchPlayers('psik'));
+    // console.log(await womClient.players.updatePlayer('psikoi'));
+    // console.log(await womClient.records.getRecordLeaderboard({ metric: 'zulrah', period: 'week' }));
+
+    // console.log(await womClient.deltas.getDeltaLeaderboard({ metric: 'zulrah', period: 'week' }));
+
+    console.log(
+      await womClient.efficiency.getEfficiencyLeaderboards({
+        metric: 'ehb',
+        playerType: 'ultimate'
+      })
+    );
+
+    console.log(await womClient.efficiency.getEHBRates('lvl3'));
+  } catch (error) {
+    console.log(error);
+  }
+}
+
+run();

package/src/utils.ts

@@ -0,0 +1,159 @@
+import axios, { AxiosError } from 'axios';
+import dayjs from 'dayjs';
+import customParseFormaPlugin from 'dayjs/plugin/customParseFormat';
+import config from './config';
+
+dayjs.extend(customParseFormaPlugin);
+
+function traverseTransform(input: any, transformation: (i: any) => any): any {
+  if (Array.isArray(input)) {
+    return input.map(item => traverseTransform(item, transformation));
+  }
+
+  if (input !== null && typeof input === 'object') {
+    return Object.fromEntries(
+      Object.keys(input).map(key => [key, traverseTransform(input[key], transformation)])
+    );
+  }
+
+  return transformation(input);
+}
+
+function isValidISODate(input: any) {
+  if (!input || typeof input !== 'string') return false;
+
+  // DayJS has a bug with strict parsing with timezones https://github.com/iamkun/dayjs/issues/929
+  // So I'll just strip the "Z" timezone
+  return input.endsWith('Z') && dayjs(input.slice(0, -1), 'YYYY-MM-DDTHH:mm:ss.SSS', true).isValid();
+}
+
+function transformDates(input: any) {
+  return traverseTransform(input, val => (isValidISODate(val) ? new Date(val) : val));
+}
+
+export type PaginationOptions = Partial<{
+  limit: number;
+  offset: number;
+}>;
+
+function handleError(requestURL: string, e: AxiosError) {
+  if (!e.response?.data) return;
+
+  const data = e.response.data as APIErrorData;
+
+  if (e.response.status === 400) {
+    throw new BadRequestError(requestURL, data.message, data.data);
+  }
+
+  if (e.response.status === 403) {
+    throw new ForbiddenError(requestURL, data.message);
+  }
+
+  if (e.response.status === 404) {
+    throw new NotFoundError(requestURL, data.message);
+  }
+
+  if (e.response.status === 429) {
+    throw new RateLimitError(requestURL, data.message);
+  }
+
+  if (e.response.status === 500) {
+    throw new InternalServerError(requestURL, data.message);
+  }
+}
+
+export async function sendPostRequest<T>(path: string, body?: any) {
+  const requestURL = `${config.apiBaseUrl}${path}`;
+
+  return axios
+    .post(requestURL, body || {})
+    .then(response => transformDates(response.data) as T)
+    .catch(e => {
+      if (axios.isAxiosError(e)) handleError(requestURL, e);
+      throw e;
+    });
+}
+
+export async function sendGetRequest<T>(path: string, params?: any) {
+  const requestURL = `${config.apiBaseUrl}${path}`;
+
+  return axios
+    .get(requestURL, { params })
+    .then(response => transformDates(response.data) as T)
+    .catch(e => {
+      if (axios.isAxiosError(e)) handleError(requestURL, e);
+      throw e;
+    });
+}
+
+interface APIErrorData {
+  message: string;
+  data?: any;
+}
+
+class BadRequestError extends Error {
+  name: string;
+  resource: string;
+  statusCode: number;
+  data?: any;
+
+  constructor(resource: string, message: string, data?: any) {
+    super(message);
+    this.name = 'BadRequestError';
+    this.resource = resource;
+    this.statusCode = 400;
+    this.data = data;
+  }
+}
+
+class ForbiddenError extends Error {
+  name: string;
+  resource: string;
+  statusCode: number;
+
+  constructor(resource: string, message: string) {
+    super(message);
+    this.name = 'ForbiddenError';
+    this.resource = resource;
+    this.statusCode = 403;
+  }
+}
+
+class NotFoundError extends Error {
+  name: string;
+  resource: string;
+  statusCode: number;
+
+  constructor(resource: string, message: string) {
+    super(message);
+    this.name = 'NotFoundError';
+    this.resource = resource;
+    this.statusCode = 404;
+  }
+}
+
+class RateLimitError extends Error {
+  name: string;
+  resource: string;
+  statusCode: number;
+
+  constructor(resource: string, message: string) {
+    super(message);
+    this.name = 'RateLimitError';
+    this.resource = resource;
+    this.statusCode = 429;
+  }
+}
+
+class InternalServerError extends Error {
+  name: string;
+  resource: string;
+  statusCode: number;
+
+  constructor(resource: string, message: string) {
+    super(message);
+    this.name = 'InternalServerError';
+    this.resource = resource;
+    this.statusCode = 500;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "rootDir": "../../",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": ["es6", "dom", "es2019"],
+    "noImplicitAny": false,
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "target": "es2015",
+    "outDir": "dist"
+  }
+}

package/dist/lib/competitions.d.ts

@@ -1,33 +0,0 @@
-declare enum CompetitionType {
-    CLASSIC = "classic",
-    TEAM = "team"
-}
-declare enum CompetitionStatus {
-    UPCOMING = "upcoming",
-    ONGOING = "ongoing",
-    FINISHED = "finished"
-}
-declare const CompetitionTypeProps: {
-    classic: {
-        name: string;
-    };
-    team: {
-        name: string;
-    };
-};
-declare const CompetitionStatusProps: {
-    upcoming: {
-        name: string;
-    };
-    ongoing: {
-        name: string;
-    };
-    finished: {
-        name: string;
-    };
-};
-declare const COMPETITION_TYPES: CompetitionType[];
-declare const COMPETITION_STATUSES: CompetitionStatus[];
-declare function findCompetitionType(typeName: string): CompetitionType | null;
-declare function findCompetitionStatus(statusName: string): CompetitionStatus | null;
-export { CompetitionType, CompetitionStatus, CompetitionTypeProps, CompetitionStatusProps, COMPETITION_TYPES, COMPETITION_STATUSES, findCompetitionType, findCompetitionStatus };

package/dist/lib/competitions.js

@@ -1,51 +0,0 @@
-"use strict";
-var _a, _b;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findCompetitionStatus = exports.findCompetitionType = exports.COMPETITION_STATUSES = exports.COMPETITION_TYPES = exports.CompetitionStatusProps = exports.CompetitionTypeProps = exports.CompetitionStatus = exports.CompetitionType = void 0;
-var CompetitionType;
-(function (CompetitionType) {
-    CompetitionType["CLASSIC"] = "classic";
-    CompetitionType["TEAM"] = "team";
-})(CompetitionType || (CompetitionType = {}));
-exports.CompetitionType = CompetitionType;
-var CompetitionStatus;
-(function (CompetitionStatus) {
-    CompetitionStatus["UPCOMING"] = "upcoming";
-    CompetitionStatus["ONGOING"] = "ongoing";
-    CompetitionStatus["FINISHED"] = "finished";
-})(CompetitionStatus || (CompetitionStatus = {}));
-exports.CompetitionStatus = CompetitionStatus;
-var CompetitionTypeProps = (_a = {},
-    _a[CompetitionType.CLASSIC] = { name: 'Classic' },
-    _a[CompetitionType.TEAM] = { name: 'Team' },
-    _a);
-exports.CompetitionTypeProps = CompetitionTypeProps;
-var CompetitionStatusProps = (_b = {},
-    _b[CompetitionStatus.UPCOMING] = { name: 'Upcoming' },
-    _b[CompetitionStatus.ONGOING] = { name: 'Ongoing' },
-    _b[CompetitionStatus.FINISHED] = { name: 'Finished' },
-    _b);
-exports.CompetitionStatusProps = CompetitionStatusProps;
-var COMPETITION_TYPES = Object.values(CompetitionType);
-exports.COMPETITION_TYPES = COMPETITION_TYPES;
-var COMPETITION_STATUSES = Object.values(CompetitionStatus);
-exports.COMPETITION_STATUSES = COMPETITION_STATUSES;
-function findCompetitionType(typeName) {
-    for (var _i = 0, _a = Object.entries(CompetitionTypeProps); _i < _a.length; _i++) {
-        var _b = _a[_i], key = _b[0], value = _b[1];
-        if (value.name === typeName)
-            return key;
-    }
-    return null;
-}
-exports.findCompetitionType = findCompetitionType;
-function findCompetitionStatus(statusName) {
-    for (var _i = 0, _a = Object.entries(CompetitionStatusProps); _i < _a.length; _i++) {
-        var _b = _a[_i], key = _b[0], value = _b[1];
-        if (value.name === statusName)
-            return key;
-    }
-    return null;
-}
-exports.findCompetitionStatus = findCompetitionStatus;
-//# sourceMappingURL=competitions.js.map

package/dist/lib/competitions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"competitions.js","sourceRoot":"","sources":["../../lib/competitions.ts"],"names":[],"mappings":";;;;AAAA,IAAK,eAGJ;AAHD,WAAK,eAAe;IAClB,sCAAmB,CAAA;IACnB,gCAAa,CAAA;AACf,CAAC,EAHI,eAAe,KAAf,eAAe,QAGnB;AAwCC,0CAAe;AAtCjB,IAAK,iBAIJ;AAJD,WAAK,iBAAiB;IACpB,0CAAqB,CAAA;IACrB,wCAAmB,CAAA;IACnB,0CAAqB,CAAA;AACvB,CAAC,EAJI,iBAAiB,KAAjB,iBAAiB,QAIrB;AAmCC,8CAAiB;AAjCnB,IAAM,oBAAoB;IACxB,GAAC,eAAe,CAAC,OAAO,IAAG,EAAE,IAAI,EAAE,SAAS,EAAE;IAC9C,GAAC,eAAe,CAAC,IAAI,IAAG,EAAE,IAAI,EAAE,MAAM,EAAE;OACzC,CAAC;AA+BA,oDAAoB;AA7BtB,IAAM,sBAAsB;IAC1B,GAAC,iBAAiB,CAAC,QAAQ,IAAG,EAAE,IAAI,EAAE,UAAU,EAAE;IAClD,GAAC,iBAAiB,CAAC,OAAO,IAAG,EAAE,IAAI,EAAE,SAAS,EAAE;IAChD,GAAC,iBAAiB,CAAC,QAAQ,IAAG,EAAE,IAAI,EAAE,UAAU,EAAE;OACnD,CAAC;AA0BA,wDAAsB;AAxBxB,IAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;AA0BvD,8CAAiB;AAzBnB,IAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;AA0B5D,oDAAoB;AAxBtB,SAAS,mBAAmB,CAAC,QAAgB;IAC3C,KAAyB,UAAoC,EAApC,KAAA,MAAM,CAAC,OAAO,CAAC,oBAAoB,CAAC,EAApC,cAAoC,EAApC,IAAoC,EAAE;QAAtD,IAAA,WAAY,EAAX,GAAG,QAAA,EAAE,KAAK,QAAA;QAClB,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO,GAAsB,CAAC;KAC5D;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAoBC,kDAAmB;AAlBrB,SAAS,qBAAqB,CAAC,UAAkB;IAC/C,KAAyB,UAAsC,EAAtC,KAAA,MAAM,CAAC,OAAO,CAAC,sBAAsB,CAAC,EAAtC,cAAsC,EAAtC,IAAsC,EAAE;QAAxD,IAAA,WAAY,EAAX,GAAG,QAAA,EAAE,KAAK,QAAA;QAClB,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU;YAAE,OAAO,GAAwB,CAAC;KAChE;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAaC,sDAAqB"}

package/dist/lib/countries.d.ts

@@ -1,17 +0,0 @@
-declare const COUNTRIES: {
-    code: string;
-    name: string;
-}[];
-declare function findCountry(countryIdentifier: string): {
-    code: string;
-    name: string;
-} | undefined;
-declare function findCountryByName(countryName: string): {
-    code: string;
-    name: string;
-} | undefined;
-declare function findCountryByCode(countryCode: string): {
-    code: string;
-    name: string;
-} | undefined;
-export { COUNTRIES, findCountry, findCountryByCode, findCountryByName };