@wise-old-man/utils 1.0.9 → 1.0.13

package/src/players.ts

@@ -1,77 +0,0 @@
-enum PlayerType {
-  UNKNOWN = 'unknown',
-  REGULAR = 'regular',
-  IRONMAN = 'ironman',
-  HARDCORE = 'hardcore',
-  ULTIMATE = 'ultimate'
-}
-
-enum PlayerBuild {
-  MAIN = 'main',
-  F2P = 'f2p',
-  LVL3 = 'lvl3',
-  ZERKER = 'zerker',
-  DEF1 = '1def',
-  HP10 = '10hp'
-}
-
-const PlayerTypeProps = {
-  [PlayerType.UNKNOWN]: { name: 'Unknown' },
-  [PlayerType.REGULAR]: { name: 'Regular' },
-  [PlayerType.IRONMAN]: { name: 'Ironman' },
-  [PlayerType.HARDCORE]: { name: 'Hardcore' },
-  [PlayerType.ULTIMATE]: { name: 'Ultimate' }
-};
-
-const PlayerBuildProps = {
-  [PlayerBuild.MAIN]: { name: 'Main' },
-  [PlayerBuild.F2P]: { name: 'F2P' },
-  [PlayerBuild.LVL3]: { name: 'Level 3' },
-  [PlayerBuild.ZERKER]: { name: 'Zerker Pure' },
-  [PlayerBuild.DEF1]: { name: '1 Defence Pure' },
-  [PlayerBuild.HP10]: { name: '10 Hitpoints Pure' }
-};
-
-const PLAYER_TYPES = Object.values(PlayerType);
-const PLAYER_BUILDS = Object.values(PlayerBuild);
-
-function findPlayerType(typeName: string): PlayerType | null {
-  for (var [key, value] of Object.entries(PlayerTypeProps)) {
-    if (value.name.toUpperCase() === typeName.toUpperCase()) return key as PlayerType;
-  }
-
-  return null;
-}
-
-function findPlayerBuild(buildName: string): PlayerBuild | null {
-  for (var [key, value] of Object.entries(PlayerBuildProps)) {
-    if (value.name.toUpperCase() === buildName.toUpperCase()) return key as PlayerBuild;
-  }
-
-  return null;
-}
-
-function standardizeUsername(username) {
-  return sanitizeUsername(username).toLowerCase();
-}
-
-// TODO: should this also remove any non alphanumeric symbols?
-function sanitizeUsername(username) {
-  return username.replace(/[-_\s]/g, ' ').trim();
-}
-
-export {
-  // Enums
-  PlayerType,
-  PlayerBuild,
-  PlayerTypeProps,
-  PlayerBuildProps,
-  // Lists
-  PLAYER_TYPES,
-  PLAYER_BUILDS,
-  // Functions
-  findPlayerType,
-  findPlayerBuild,
-  sanitizeUsername,
-  standardizeUsername
-};

package/src/strings.ts

@@ -1,31 +0,0 @@
-function formatNumber(num: number, withLetters = false) {
-  if (num === undefined || num === null) return -1;
-
-  // If number is float
-  if (num % 1 !== 0) {
-    return (Math.round(num * 100) / 100).toString().replace(/(\d)(?=(\d{3})+(?!\d))/g, '$1,');
-  }
-
-  if ((num < 10000 && num > -10000) || !withLetters) {
-    return num.toString().replace(/(\d)(?=(\d{3})+(?!\d))/g, '$1,');
-  }
-
-  // < 10 million
-  if (num < 10_000_000 && num > -10_000_000) {
-    return `${Math.floor(num / 1000)}k`;
-  }
-
-  // < 1 billion
-  if (num < 1_000_000_000 && num > -1_000_000_000) {
-    return `${Math.round((num / 1000000 + Number.EPSILON) * 100) / 100}m`;
-  }
-
-  return `${Math.round((num / 1000000000 + Number.EPSILON) * 100) / 100}b`;
-}
-
-function padNumber(value: number): string {
-  if (!value) return '00';
-  return value < 10 ? `0${value}` : value.toString();
-}
-
-export { formatNumber, padNumber };

package/tests/competitions.test.ts

@@ -1,32 +0,0 @@
-import {
-  findCompetitionType,
-  findCompetitionStatus,
-  CompetitionType,
-  CompetitionStatus,
-  CompetitionTypeProps,
-  COMPETITION_TYPES,
-  COMPETITION_STATUSES,
-  CompetitionStatusProps
-} from '../src/competitions';
-
-describe('Util - Competitions', () => {
-  test('Props', () => {
-    expect(COMPETITION_TYPES.some(t => !(t in CompetitionTypeProps))).toBe(false);
-    expect(Object.keys(CompetitionType).length).toBe(Object.keys(CompetitionTypeProps).length);
-
-    expect(COMPETITION_STATUSES.some(t => !(t in CompetitionStatusProps))).toBe(false);
-    expect(Object.keys(CompetitionStatus).length).toBe(Object.keys(CompetitionStatusProps).length);
-  });
-
-  test('findCompetitionType', () => {
-    expect(findCompetitionType('Classic')).toBe(CompetitionType.CLASSIC);
-    expect(findCompetitionType('Team')).toBe(CompetitionType.TEAM);
-    expect(findCompetitionType('Other')).toBe(null);
-  });
-
-  test('findCompetitionStatus', () => {
-    expect(findCompetitionStatus('Upcoming')).toBe(CompetitionStatus.UPCOMING);
-    expect(findCompetitionStatus('Ongoing')).toBe(CompetitionStatus.ONGOING);
-    expect(findCompetitionStatus('Other')).toBe(null);
-  });
-});

package/tests/countries.test.ts

@@ -1,22 +0,0 @@
-import { findCountryByCode, findCountryByName, findCountry } from '../src/countries';
-
-describe('Util - Countries', () => {
-  test('findCountryByCode', () => {
-    expect(findCountryByCode('UK')?.code).toBe('GB');
-    expect(findCountryByCode('USA')?.code).toBe('US');
-    expect(findCountryByCode('PT')?.name).toBe('Portugal');
-    expect(findCountryByCode('FR')?.name).toBe('France');
-  });
-
-  test('findCountryByName', () => {
-    expect(findCountryByName('portugal')?.code).toBe('PT');
-    expect(findCountryByName('Italy')?.code).toBe('IT');
-    expect(findCountryByName('ANGOLA')?.name).toBe('Angola');
-  });
-
-  test('findCountry', () => {
-    expect(findCountry('portugal')?.code).toBe('PT');
-    expect(findCountry('it')?.code).toBe('IT');
-    expect(findCountry('AO')?.name).toBe('Angola');
-  });
-});

package/tests/experience.test.ts

@@ -1,23 +0,0 @@
-import { getCombatLevel, getLevel, getExpForLevel, SKILL_EXP_AT_99 } from '../src/experience';
-
-describe('Util - Experience', () => {
-  test('getExpForLevel', () => {
-    expect(getExpForLevel(1)).toBe(0);
-    expect(getExpForLevel(2)).toBe(83);
-    expect(getExpForLevel(10)).toBe(1154);
-    expect(getExpForLevel(99)).toBe(SKILL_EXP_AT_99);
-  });
-
-  test('getLevel', () => {
-    expect(getLevel(SKILL_EXP_AT_99)).toBe(99);
-    expect(getLevel(110_000)).toBe(50);
-    expect(getLevel(getExpForLevel(67))).toBe(67);
-  });
-
-  test('getCombatLevel', () => {
-    expect(getCombatLevel(1, 1, 1, 1, 1, 10, 1)).toBe(3);
-    expect(getCombatLevel(1, 1, 1, 1, 1, 10, 99)).toBe(15);
-    expect(getCombatLevel(99, 99, 99, 99, 99, 99, 99)).toBe(126);
-    expect(getCombatLevel(80, 87, 78, 80, 81, 85, 80)).toBe(105);
-  });
-});

package/tests/groups.test.ts

@@ -1,14 +0,0 @@
-import { GroupRole, GROUP_ROLES, GroupRoleProps, findGroupRole } from '../src/groups';
-
-describe('Util - Groups', () => {
-  test('Props', () => {
-    expect(GROUP_ROLES.some(t => !(t in GroupRoleProps))).toBe(false);
-    expect(Object.keys(GroupRole).length).toBe(Object.keys(GroupRoleProps).length);
-  });
-
-  test('findGroupRole', () => {
-    expect(findGroupRole('artisan')).toBe(GroupRole.ARTISAN);
-    expect(findGroupRole('SCOUT')).toBe(GroupRole.SCOUT);
-    expect(findGroupRole('Other')).toBe(null);
-  });
-});

package/tests/metrics.test.ts

@@ -1,113 +0,0 @@
-import {
-  METRICS,
-  Metrics,
-  MetricProps,
-  findMetric,
-  Metric,
-  isSkill,
-  isBoss,
-  isActivity,
-  isVirtualMetric,
-  getMetricRankKey,
-  getMetricValueKey,
-  getMetricMeasure,
-  getMetricName,
-  getMinimumBossKc,
-  getParentVirtualMetric,
-  parseMetricAbbreviation,
-  MetricMeasure
-} from '../src/metrics';
-
-describe('Util - Metrics', () => {
-  test('Props', () => {
-    expect(METRICS.some(t => !(t in MetricProps))).toBe(false);
-    expect(Object.keys(Metrics).length).toBe(Object.keys(MetricProps).length);
-  });
-
-  test('findMetric', () => {
-    expect(findMetric('AGILITY')).toBe(Metrics.AGILITY);
-    expect(findMetric('MAgiC')).toBe(Metrics.MAGIC);
-    expect(findMetric('Other')).toBe(null);
-  });
-
-  test('isSkill', () => {
-    expect(isSkill('Other' as Metric)).toBe(false);
-    expect(isSkill(Metrics.ZULRAH)).toBe(false);
-    expect(isSkill(Metrics.LAST_MAN_STANDING)).toBe(false);
-    expect(isSkill(Metrics.WOODCUTTING)).toBe(true);
-    expect(isSkill(findMetric('Runecrafting') as Metric)).toBe(true);
-  });
-
-  test('isBoss', () => {
-    expect(isBoss('Other' as Metric)).toBe(false);
-    expect(isBoss(Metrics.WOODCUTTING)).toBe(false);
-    expect(isBoss(Metrics.LAST_MAN_STANDING)).toBe(false);
-    expect(isBoss(Metrics.ZULRAH)).toBe(true);
-    expect(isBoss(findMetric('Obor') as Metric)).toBe(true);
-  });
-
-  test('isActivity', () => {
-    expect(isActivity('Other' as Metric)).toBe(false);
-    expect(isActivity(Metrics.WOODCUTTING)).toBe(false);
-    expect(isActivity(Metrics.ZULRAH)).toBe(false);
-    expect(isActivity(Metrics.LAST_MAN_STANDING)).toBe(true);
-    expect(isActivity(findMetric('Soul Wars Zeal') as Metric)).toBe(true);
-  });
-
-  test('isVirtualMetric', () => {
-    expect(isVirtualMetric('Other' as Metric)).toBe(false);
-    expect(isVirtualMetric(Metrics.WOODCUTTING)).toBe(false);
-    expect(isVirtualMetric(Metrics.LAST_MAN_STANDING)).toBe(false);
-    expect(isVirtualMetric(Metrics.EHP)).toBe(true);
-    expect(isVirtualMetric(findMetric('EHB') as Metric)).toBe(true);
-  });
-
-  test('getMetricRankKey', () => {
-    expect(getMetricRankKey(Metrics.EHP)).toBe('ehpRank');
-    expect(getMetricRankKey(Metrics.ZALCANO)).toBe('zalcanoRank');
-    expect(getMetricRankKey(Metrics.WOODCUTTING)).toBe('woodcuttingRank');
-    expect(getMetricRankKey(Metrics.SOUL_WARS_ZEAL)).toBe('soul_wars_zealRank');
-  });
-
-  test('getMetricValueKey', () => {
-    expect(getMetricValueKey(Metrics.EHP)).toBe('ehpValue');
-    expect(getMetricValueKey(Metrics.ZALCANO)).toBe('zalcanoKills');
-    expect(getMetricValueKey(Metrics.WOODCUTTING)).toBe('woodcuttingExperience');
-    expect(getMetricValueKey(Metrics.SOUL_WARS_ZEAL)).toBe('soul_wars_zealScore');
-  });
-
-  test('getMetricMeasure', () => {
-    expect(getMetricMeasure(Metrics.EHP)).toBe(MetricMeasure.VALUE);
-    expect(getMetricMeasure(Metrics.ZALCANO)).toBe(MetricMeasure.KILLS);
-    expect(getMetricMeasure(Metrics.WOODCUTTING)).toBe(MetricMeasure.EXPERIENCE);
-    expect(getMetricMeasure(Metrics.SOUL_WARS_ZEAL)).toBe(MetricMeasure.SCORE);
-  });
-
-  test('getMetricName', () => {
-    expect(getMetricName(Metrics.EHP)).toBe('EHP');
-    expect(getMetricName(Metrics.ZALCANO)).toBe('Zalcano');
-    expect(getMetricName(Metrics.WOODCUTTING)).toBe('Woodcutting');
-    expect(getMetricName(Metrics.SOUL_WARS_ZEAL)).toBe('Soul Wars Zeal');
-  });
-
-  test('getMinimumBossKc', () => {
-    expect(getMinimumBossKc(Metrics.ATTACK)).toBe(0);
-    expect(getMinimumBossKc(Metrics.ZALCANO)).toBe(50);
-    expect(getMinimumBossKc(Metrics.TZTOK_JAD)).toBe(10);
-    expect(getMinimumBossKc(Metrics.TZKAL_ZUK)).toBe(2);
-  });
-
-  test('getParentVirtualMetric', () => {
-    expect(getParentVirtualMetric(Metrics.EHP)).toBe(null);
-    expect(getParentVirtualMetric(Metrics.ZALCANO)).toBe(Metrics.EHB);
-    expect(getParentVirtualMetric(Metrics.WOODCUTTING)).toBe(Metrics.EHP);
-    expect(getParentVirtualMetric(Metrics.SOUL_WARS_ZEAL)).toBe(null);
-  });
-
-  test('parseMetricAbbreviation', () => {
-    expect(parseMetricAbbreviation('')).toBe(null);
-    expect(parseMetricAbbreviation('agility')).toBe(Metrics.AGILITY);
-    expect(parseMetricAbbreviation('SIRE')).toBe(Metrics.ABYSSAL_SIRE);
-    expect(parseMetricAbbreviation('corp')).toBe(Metrics.CORPOREAL_BEAST);
-  });
-});

package/tests/numbers.test.ts

@@ -1,9 +0,0 @@
-import { round } from '../src/numbers';
-
-describe('Util - Numbers', () => {
-  test('round', () => {
-    expect(round(12.34567, 2)).toBe(12.35);
-    expect(round(12.34567, 1)).toBe(12.3);
-    expect(round(-5.6657, 0)).toBe(-6);
-  });
-});

package/tests/periods.test.ts

@@ -1,49 +0,0 @@
-import {
-  PERIODS,
-  Period,
-  PeriodProps,
-  findPeriod,
-  isValidPeriod,
-  parsePeriodExpression
-} from '../src/periods';
-
-describe('Util - Periods', () => {
-  test('Props', () => {
-    expect(PERIODS.some(t => !(t in PeriodProps))).toBe(false);
-    expect(Object.keys(Period).length).toBe(Object.keys(PeriodProps).length);
-  });
-
-  test('findPeriod', () => {
-    expect(findPeriod('week')).toBe(Period.WEEK);
-    expect(findPeriod('MONTH')).toBe(Period.MONTH);
-    expect(findPeriod('Other')).toBe(null);
-  });
-
-  test('isValidPeriod', () => {
-    expect(isValidPeriod('week')).toBe(true);
-    expect(isValidPeriod('WEEK')).toBe(false);
-    expect(isValidPeriod('Other')).toBe(false);
-  });
-
-  test('parsePeriodExpression', () => {
-    expect(parsePeriodExpression('week')).toEqual({
-      expression: 'week',
-      durationMs: PeriodProps[Period.WEEK].milliseconds
-    });
-
-    expect(parsePeriodExpression('3w')).toEqual({
-      expression: '3w',
-      durationMs: 3 * PeriodProps[Period.WEEK].milliseconds
-    });
-
-    expect(parsePeriodExpression('1y2m3w')).toEqual({
-      expression: '1y2m3w',
-      durationMs:
-        PeriodProps[Period.YEAR].milliseconds +
-        2 * PeriodProps[Period.MONTH].milliseconds +
-        3 * PeriodProps[Period.WEEK].milliseconds
-    });
-
-    expect(parsePeriodExpression('other')).toEqual(null);
-  });
-});

package/tests/players.test.ts

@@ -1,44 +0,0 @@
-import {
-  PLAYER_TYPES,
-  PLAYER_BUILDS,
-  PlayerTypeProps,
-  PlayerBuildProps,
-  PlayerType,
-  PlayerBuild,
-  findPlayerType,
-  findPlayerBuild,
-  sanitizeUsername,
-  standardizeUsername
-} from '../src/players';
-
-describe('Util - Players', () => {
-  test('Props', () => {
-    expect(PLAYER_TYPES.some(t => !(t in PlayerTypeProps))).toBe(false);
-    expect(Object.keys(PlayerType).length).toBe(Object.keys(PlayerTypeProps).length);
-
-    expect(PLAYER_BUILDS.some(t => !(t in PlayerBuildProps))).toBe(false);
-    expect(Object.keys(PlayerBuild).length).toBe(Object.keys(PlayerBuildProps).length);
-  });
-
-  test('findPlayerType', () => {
-    expect(findPlayerType('Hardcore')).toBe(PlayerType.HARDCORE);
-    expect(findPlayerType('ultimate')).toBe(PlayerType.ULTIMATE);
-    expect(findPlayerType('Other')).toBe(null);
-  });
-
-  test('findPlayerBuild', () => {
-    expect(findPlayerBuild('F2P')).toBe(PlayerBuild.F2P);
-    expect(findPlayerBuild('level 3')).toBe(PlayerBuild.LVL3);
-    expect(findPlayerBuild('Other')).toBe(null);
-  });
-
-  test('sanitizeUsername', () => {
-    expect(sanitizeUsername(' IRON Mammal_ ')).toBe('IRON Mammal');
-    expect(sanitizeUsername('    __PSIKOI')).toBe('PSIKOI');
-  });
-
-  test('standardizeUsername', () => {
-    expect(standardizeUsername(' IRON Mammal_ ')).toBe('iron mammal');
-    expect(standardizeUsername('    __PSIKOI')).toBe('psikoi');
-  });
-});

package/tests/strings.test.ts

@@ -1,27 +0,0 @@
-import { formatNumber, padNumber } from '../src/strings';
-
-describe('Util - Strings', () => {
-  test('formatNumber', () => {
-    expect(formatNumber(1.234)).toBe('1.23');
-    expect(formatNumber(5.1)).toBe('5.1');
-
-    expect(formatNumber(500)).toBe('500');
-    expect(formatNumber(1000)).toBe('1,000');
-    expect(formatNumber(10_000)).toBe('10,000');
-    expect(formatNumber(100_000)).toBe('100,000');
-    expect(formatNumber(1_000_000)).toBe('1,000,000');
-
-    expect(formatNumber(-1000, true)).toBe('-1,000');
-    expect(formatNumber(10_000, true)).toBe('10k');
-    expect(formatNumber(9_123_000, true)).toBe('9123k');
-    expect(formatNumber(-10_500_000, true)).toBe('-10.5m');
-    expect(formatNumber(1_123_456_000, true)).toBe('1.12b');
-  });
-
-  test('padNumber', () => {
-    expect(padNumber(0)).toBe('00');
-    expect(padNumber(1)).toBe('01');
-    expect(padNumber(10)).toBe('10');
-    expect(padNumber(123)).toBe('123');
-  });
-});

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": ["es6", "dom", "es2017"],
-    "target": "es5",
-    "module": "commonjs",
-    "esModuleInterop": true,
-    "noImplicitAny": false,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "outDir": "dist",
-    "sourceMap": true,
-    "declaration": true
-  },
-  "exclude": ["node_modules", "dist", "tests"]
-}