osrs-tools 2.3.0 → 2.3.3

package/dist/out-tsc/source/runescape/tools/experience.js

@@ -0,0 +1,128 @@
+// Experience per level in runescape
+/**
+ * Get experience required for a given level
+ * @param level
+ * @returns
+ */
+export function getExperienceForLevel(level) {
+    if (level < 1 || level > 99) {
+        throw new Error('Level must be between 1 and 99');
+    }
+    return LEVEL_TO_EXPERIENCE[level];
+}
+/**
+ * Get level for a given experience
+ * @param exp
+ * @returns
+ */
+export function getLevelForExperience(exp) {
+    let level = 1;
+    while (level < 99 && getExperienceForLevel(level + 1) <= exp) {
+        level++;
+    }
+    return level;
+}
+/**
+ * Mapping of levels to experience points
+ */
+export const LEVEL_TO_EXPERIENCE = {
+    1: 0,
+    2: 83,
+    3: 174,
+    4: 276,
+    5: 388,
+    6: 512,
+    7: 650,
+    8: 801,
+    9: 969,
+    10: 1154,
+    11: 1358,
+    12: 1584,
+    13: 1833,
+    14: 2107,
+    15: 2411,
+    16: 2746,
+    17: 3115,
+    18: 3523,
+    19: 3973,
+    20: 4470,
+    21: 5018,
+    22: 5624,
+    23: 6291,
+    24: 7028,
+    25: 7842,
+    26: 8740,
+    27: 9730,
+    28: 10824,
+    29: 12031,
+    30: 13363,
+    31: 14833,
+    32: 16456,
+    33: 18247,
+    34: 20224,
+    35: 22406,
+    36: 24815,
+    37: 27473,
+    38: 30408,
+    39: 33648,
+    40: 37224,
+    41: 41171,
+    42: 45529,
+    43: 50339,
+    44: 55649,
+    45: 61512,
+    46: 67983,
+    47: 75127,
+    48: 83014,
+    49: 91721,
+    50: 101333,
+    51: 111945,
+    52: 123660,
+    53: 136594,
+    54: 150872,
+    55: 166636,
+    56: 184040,
+    57: 203254,
+    58: 224466,
+    59: 247886,
+    60: 273742,
+    61: 302288,
+    62: 333804,
+    63: 368599,
+    64: 407015,
+    65: 449428,
+    66: 496254,
+    67: 547953,
+    68: 605032,
+    69: 668051,
+    70: 737627,
+    71: 814445,
+    72: 899257,
+    73: 992895,
+    74: 1096278,
+    75: 1210421,
+    76: 1336443,
+    77: 1475581,
+    78: 1629200,
+    79: 1798808,
+    80: 1986068,
+    81: 2192818,
+    82: 2421087,
+    83: 2673114,
+    84: 2951373,
+    85: 3258594,
+    86: 3597792,
+    87: 3972294,
+    88: 4385776,
+    89: 4842295,
+    90: 5346332,
+    91: 5902831,
+    92: 6517253,
+    93: 7195629,
+    94: 7944614,
+    95: 8771558,
+    96: 9684577,
+    97: 10692629,
+    98: 11805606,
+    99: 13034431,
+};

package/dist/out-tsc/source/runescape/tools/getAccount.js

@@ -0,0 +1,26 @@
+"use strict";
+// import { getStatsByGamemode, getSkillPage } from 'osrs-json-hiscores';
+// /*
+// To run this file in Command Prompt, use:
+// npx ts-node tools/getAccount.ts <username> [gamemode]
+// Or, if you have ts-node installed globally:
+// ts-node tools/getAccount.ts <username> [gamemode]
+// Replace <username> and [gamemode] with the desired values.
+// */
+// // Usage: ts-node tools/getAccount.ts <username> [gamemode]
+// // const [, username, gamemode] = process.argv;
+// const gamemode = 'main'; // Default gamemode
+// const username = 'A Squeezer';
+// if (!username) {
+//   console.error('Usage: ts-node tools/getAccount.ts <username> [gamemode]');
+//   process.exit(1);
+// }
+// (async () => {
+//   try {
+//     const stats = await getStatsByGamemode(username, gamemode || 'main');
+//     console.log(JSON.stringify(stats, null, 2));
+//   } catch (err) {
+//     console.error('Error fetching account:', err);
+//     process.exit(1);
+//   }
+// })();

package/dist/out-tsc/source/runescape/utils/cache.js

@@ -0,0 +1,124 @@
+/**
+ * Generic cache implementation with LRU eviction and TTL support
+ */
+export class Cache {
+    store = new Map();
+    maxSize;
+    ttl;
+    /**
+     * Creates a new Cache instance
+     * @param options Cache configuration options
+     */
+    constructor(options = {}) {
+        this.maxSize = options.maxSize || 100;
+        this.ttl = options.ttl;
+    }
+    /**
+     * Store a value in the cache
+     * @param key Cache key
+     * @param value Value to store
+     * @param ttl Optional TTL override for this item
+     */
+    set(key, value, ttl) {
+        // Enforce size limit using LRU eviction
+        if (this.store.size >= this.maxSize) {
+            const firstKey = this.store.keys().next().value;
+            this.store.delete(firstKey);
+        }
+        const expiresAt = ttl || this.ttl ? Date.now() + (ttl || this.ttl) : undefined;
+        this.store.set(key, { expiresAt, value });
+    }
+    /**
+     * Retrieve a value from the cache
+     * @param key Cache key
+     * @returns Stored value or undefined if not found/expired
+     */
+    get(key) {
+        const item = this.store.get(key);
+        if (!item) {
+            return undefined;
+        }
+        // Check if item has expired
+        if (item.expiresAt && Date.now() > item.expiresAt) {
+            this.store.delete(key);
+            return undefined;
+        }
+        return item.value;
+    }
+    /**
+     * Remove an item from the cache
+     * @param key Cache key
+     * @returns true if item was found and removed
+     */
+    delete(key) {
+        return this.store.delete(key);
+    }
+    /**
+     * Clear all items from the cache
+     */
+    clear() {
+        this.store.clear();
+    }
+    /**
+     * Get the number of items in the cache
+     */
+    get size() {
+        return this.store.size;
+    }
+    /**
+     * Get all valid keys in the cache
+     * @returns Array of cache keys
+     */
+    keys() {
+        const now = Date.now();
+        return Array.from(this.store.entries())
+            .filter(([, item]) => !item.expiresAt || item.expiresAt > now)
+            .map(([key]) => key);
+    }
+    /**
+     * Remove all expired items from the cache
+     * @returns Number of items removed
+     */
+    prune() {
+        const now = Date.now();
+        let removed = 0;
+        for (const [key, item] of this.store.entries()) {
+            if (item.expiresAt && item.expiresAt <= now) {
+                this.store.delete(key);
+                removed++;
+            }
+        }
+        return removed;
+    }
+    /**
+     * Check if a key exists in the cache and isn't expired
+     * @param key Cache key
+     * @returns true if key exists and isn't expired
+     */
+    has(key) {
+        const item = this.store.get(key);
+        if (!item) {
+            return false;
+        }
+        if (item.expiresAt && Date.now() > item.expiresAt) {
+            this.store.delete(key);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Get or set a cache value
+     * @param key Cache key
+     * @param factory Function to create value if not found
+     * @returns Cached or newly created value
+     */
+    async getOrSet(key, factory) {
+        const existing = this.get(key);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const value = await factory();
+        this.set(key, value);
+        return value;
+    }
+}

package/dist/out-tsc/source/runescape/utils/validation.js

@@ -0,0 +1,160 @@
+import { ValidationError } from '../errors';
+import { Skill } from '../model/account/Skill';
+/**
+ * Validates a skill level value
+ * @param level The level to validate
+ * @param skillName Name of the skill (for error context)
+ * @throws {ValidationError} If level is invalid
+ */
+export function validateSkillLevel(level, skillName) {
+    if (!Number.isInteger(level)) {
+        throw new ValidationError('level', level, 'Skill level must be an integer', {
+            skillName,
+            type: 'integer',
+        });
+    }
+    if (level < 1 || level > 99) {
+        throw new ValidationError('level', level, 'Skill level must be between 1 and 99', {
+            max: 99,
+            min: 1,
+            skillName,
+        });
+    }
+}
+/**
+ * Validates quest points value
+ * @param points The quest points to validate
+ * @throws {ValidationError} If points value is invalid
+ */
+export function validateQuestPoints(points) {
+    if (!Number.isInteger(points)) {
+        throw new ValidationError('questPoints', points, 'Quest points must be an integer', {
+            type: 'integer',
+        });
+    }
+    if (points < 0) {
+        throw new ValidationError('questPoints', points, 'Quest points cannot be negative', {
+            min: 0,
+        });
+    }
+    // Current max quest points in OSRS (as of 2025)
+    const MAX_QUEST_POINTS = 300;
+    if (points > MAX_QUEST_POINTS) {
+        throw new ValidationError('questPoints', points, `Quest points cannot exceed ${MAX_QUEST_POINTS}`, {
+            max: MAX_QUEST_POINTS,
+        });
+    }
+}
+/**
+ * Validates combat level value
+ * @param level The combat level to validate
+ * @throws {ValidationError} If level is invalid
+ */
+export function validateCombatLevel(level) {
+    if (!Number.isInteger(level)) {
+        throw new ValidationError('combatLevel', level, 'Combat level must be an integer', {
+            type: 'integer',
+        });
+    }
+    if (level < 3 || level > 126) {
+        throw new ValidationError('combatLevel', level, 'Combat level must be between 3 and 126', {
+            max: 126,
+            min: 3,
+        });
+    }
+}
+/**
+ * Validates a skill name
+ * @param name The skill name to validate
+ * @throws {ValidationError} If name is invalid
+ */
+export function validateSkillName(name) {
+    const normalizedName = name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
+    if (!(normalizedName in Skill)) {
+        throw new ValidationError('skillName', name, 'Invalid skill name', {
+            validSkills: Object.values(Skill),
+        });
+    }
+}
+/**
+ * Type guard for checking if a value is a valid skill name
+ * @param name The value to check
+ * @returns True if value is a valid skill name
+ */
+export function isValidSkillName(name) {
+    try {
+        validateSkillName(name);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validates experience (XP) value
+ * @param xp The XP value to validate
+ * @param skillName Name of the skill (for error context)
+ * @throws {ValidationError} If XP value is invalid
+ */
+export function validateExperience(xp, skillName) {
+    if (!Number.isInteger(xp)) {
+        throw new ValidationError('experience', xp, 'Experience must be an integer', {
+            skillName,
+            type: 'integer',
+        });
+    }
+    if (xp < 0) {
+        throw new ValidationError('experience', xp, 'Experience cannot be negative', {
+            min: 0,
+            skillName,
+        });
+    }
+    const MAX_XP = 200_000_000;
+    if (xp > MAX_XP) {
+        throw new ValidationError('experience', xp, `Experience cannot exceed ${MAX_XP}`, {
+            max: MAX_XP,
+            skillName,
+        });
+    }
+}
+/**
+ * Validates rank value
+ * @param rank The rank value to validate
+ * @param context Additional context for error message
+ * @throws {ValidationError} If rank value is invalid
+ */
+export function validateRank(rank, context) {
+    if (!Number.isInteger(rank)) {
+        throw new ValidationError('rank', rank, 'Rank must be an integer', {
+            context,
+            type: 'integer',
+        });
+    }
+    if (rank < 1) {
+        throw new ValidationError('rank', rank, 'Rank must be positive', {
+            context,
+            min: 1,
+        });
+    }
+}
+/**
+ * Validates an account name
+ * @param name The account name to validate
+ * @throws {ValidationError} If name is invalid
+ */
+export function validateAccountName(name) {
+    if (!name) {
+        throw new ValidationError('name', name, 'Account name is required');
+    }
+    if (name.length > 12) {
+        throw new ValidationError('name', name, 'Account name cannot exceed 12 characters', {
+            maxLength: 12,
+        });
+    }
+    const validNameRegex = /^[a-zA-Z0-9 -_]+$/;
+    if (!validNameRegex.test(name)) {
+        throw new ValidationError('name', name, 'Account name contains invalid characters', {
+            pattern: validNameRegex.toString(),
+        });
+    }
+}