lol-constants 2.26.0 → 3.0.0-rc.1

package/dist/helpers/item.d.ts

@@ -0,0 +1,39 @@
+import { ItemId, ItemName, Items, ItemsArr } from '../objects/generated/Items';
+import { MapId } from '../objects/Maps';
+/**
+ * Get an item by its **id** or **name**.
+ *
+ * Item categorization is focused on Summoner's Rift. Item's `srType` field denotes:
+ * - `0`: Starter items (Summoner's Rift)
+ * - `1`: Basic items (Summoner's Rift)
+ * - `2`: Epic items (Summoner's Rift)
+ * - `3`: Legendary items (Summoner's Rift)
+ * - `11`: Trinkets (Summoner's Rift)
+ * - `12`: Boots (Summoner's Rift)
+ * - `13`: Consumables (Summoner's Rift)
+ * - `-1`: Misc. & Uncategorized (Summoner's Rift & other maps)
+ *
+ * ---
+ * Second argument `mapId` only applies to getting an item by its **name**:
+ *
+ * Since there can be duplicate item names intended for different maps,
+ * `mapId` denotes which map should be prioritized.
+ * Function may still return an item for a provided `itemName`
+ * even if it does not match the provided `mapId`.
+ *
+ * Defaults to `11` (Summoner's Rift).
+ *
+ * Use `lol.item.isAvailable` to determine whether item is available on a certain map.
+ */
+export declare function getItem(id_name: ItemId | ItemName, mapId?: MapId): typeof Items[keyof typeof Items];
+export declare function isStarterItem(item_id_name: typeof ItemsArr[number] | ItemId | ItemName): boolean;
+export declare function isBasicItem(item_id_name: typeof ItemsArr[number] | ItemId | ItemName): boolean;
+export declare function isEpicItem(item_id_name: typeof ItemsArr[number] | ItemId | ItemName): boolean;
+export declare function isLegendaryItem(item_id_name: typeof ItemsArr[number] | ItemId | ItemName): boolean;
+export declare function isTrinketItem(item_id_name: typeof ItemsArr[number] | ItemId | ItemName): boolean;
+export declare function isBootsItem(item_id_name: typeof ItemsArr[number] | ItemId | ItemName): boolean;
+export declare function isConsumableItem(item_id_name: typeof ItemsArr[number] | ItemId | ItemName): boolean;
+/** Check whether item is available on a certain map. */
+export declare function isItemAvailableOnMap(itemId: ItemId, mapId: MapId): boolean;
+export declare function isItemId(id: number | null | undefined): id is ItemId;
+export declare function isItemName(name: string | null | undefined): name is ItemName;

package/dist/helpers/item.js

@@ -0,0 +1,113 @@
+import { ItemSrTypes } from '../enums/ItemSrTypes';
+import { bootsItemIds, itemNames, Items, } from '../objects/generated/Items';
+import { MapsArr } from '../objects/Maps';
+/**
+ * Get an item by its **id** or **name**.
+ *
+ * Item categorization is focused on Summoner's Rift. Item's `srType` field denotes:
+ * - `0`: Starter items (Summoner's Rift)
+ * - `1`: Basic items (Summoner's Rift)
+ * - `2`: Epic items (Summoner's Rift)
+ * - `3`: Legendary items (Summoner's Rift)
+ * - `11`: Trinkets (Summoner's Rift)
+ * - `12`: Boots (Summoner's Rift)
+ * - `13`: Consumables (Summoner's Rift)
+ * - `-1`: Misc. & Uncategorized (Summoner's Rift & other maps)
+ *
+ * ---
+ * Second argument `mapId` only applies to getting an item by its **name**:
+ *
+ * Since there can be duplicate item names intended for different maps,
+ * `mapId` denotes which map should be prioritized.
+ * Function may still return an item for a provided `itemName`
+ * even if it does not match the provided `mapId`.
+ *
+ * Defaults to `11` (Summoner's Rift).
+ *
+ * Use `lol.item.isAvailable` to determine whether item is available on a certain map.
+ */
+export function getItem(id_name, mapId = 11) {
+    if (typeof id_name == 'number')
+        return Items[id_name];
+    return Items[getItemIdByName(id_name, mapId)];
+}
+/** @see `getItem` */
+function getItemIdByName(itemName, mapId = 11) {
+    const itemIdOrMaps = itemNames[itemName];
+    if (typeof itemIdOrMaps == 'number') {
+        const itemId = itemIdOrMaps;
+        return itemId;
+    }
+    else {
+        const maps = itemIdOrMaps;
+        const itemId = maps[mapId];
+        if (itemId != null) {
+            return itemId;
+        }
+        else {
+            // Take another map, at least. In order: Summoner's Rift, Howling Abyss, Arena etc.
+            let itemId;
+            if (itemId = maps[11])
+                return itemId;
+            if (itemId = maps[12])
+                return itemId;
+            if (itemId = maps[30])
+                return itemId;
+            for (const { id } of MapsArr) {
+                if (itemId = maps[id])
+                    return itemId;
+            }
+            return 2003; // If all else fails, return a health potion (though generated files by design should not reach this)
+        }
+    }
+}
+export function isStarterItem(item_id_name) {
+    if (typeof item_id_name == 'object')
+        return item_id_name.srType == ItemSrTypes.STARTER;
+    return getItem(item_id_name).srType == ItemSrTypes.STARTER;
+}
+export function isBasicItem(item_id_name) {
+    if (typeof item_id_name == 'object')
+        return item_id_name.srType == ItemSrTypes.BASIC;
+    return getItem(item_id_name).srType == ItemSrTypes.BASIC;
+}
+export function isEpicItem(item_id_name) {
+    if (typeof item_id_name == 'object')
+        return item_id_name.srType == ItemSrTypes.EPIC;
+    return getItem(item_id_name).srType == ItemSrTypes.EPIC;
+}
+export function isLegendaryItem(item_id_name) {
+    if (typeof item_id_name == 'object')
+        return item_id_name.srType == ItemSrTypes.LEGENDARY;
+    return getItem(item_id_name).srType == ItemSrTypes.LEGENDARY;
+}
+export function isTrinketItem(item_id_name) {
+    if (typeof item_id_name == 'object')
+        return item_id_name.srType == ItemSrTypes.TRINKET;
+    return getItem(item_id_name).srType == ItemSrTypes.TRINKET;
+}
+export function isBootsItem(item_id_name) {
+    if (typeof item_id_name == 'object')
+        return item_id_name.id in bootsItemIds;
+    if (typeof item_id_name == 'number')
+        return item_id_name in bootsItemIds;
+    return getItemIdByName(item_id_name) in bootsItemIds;
+}
+export function isConsumableItem(item_id_name) {
+    if (typeof item_id_name == 'object')
+        return item_id_name.srType == ItemSrTypes.CONSUMABLE;
+    return getItem(item_id_name).srType == ItemSrTypes.CONSUMABLE;
+}
+/** Check whether item is available on a certain map. */
+export function isItemAvailableOnMap(itemId, mapId) {
+    const mapsObjOrItemId = itemNames[Items[itemId].name];
+    if (typeof mapsObjOrItemId == 'number')
+        return false; // Means item is disabled on all maps
+    return mapId in mapsObjOrItemId;
+}
+export function isItemId(id) {
+    return typeof id == 'number' && id in Items;
+}
+export function isItemName(name) {
+    return typeof name == 'string' && name in itemNames;
+}

package/dist/helpers/riotId.d.ts

@@ -0,0 +1,16 @@
+/** E.g. `Faker#T1` ⇒ `{name: 'Faker', tag: 'T1'}` */
+export declare function splitRiotId(riotId: string, 
+/** @default '#' */
+splitChar?: string): RiotId;
+/** Default `splitChar` is "#".  */
+export declare function makeRiotId(riotId: RiotId, 
+/** @default '#' */
+splitChar?: string): string;
+/** Default `splitChar` is "#".  */
+export declare function validateRiotId(riotId: string, 
+/** @default '#' */
+splitChar?: string): boolean;
+export type RiotId = {
+    name: string;
+    tag: string;
+};

package/dist/helpers/riotId.js

@@ -0,0 +1,34 @@
+const maxRiotGameNameCharCount = 16;
+const maxRiotTaglineCharCount = 5;
+/** E.g. `Faker#T1` ⇒ `{name: 'Faker', tag: 'T1'}` */
+export function splitRiotId(riotId, 
+/** @default '#' */
+splitChar = '#') {
+    var _a, _b;
+    const split = riotId.split(splitChar);
+    let name = (_a = split[0]) !== null && _a !== void 0 ? _a : '';
+    let tag = (_b = split[1]) !== null && _b !== void 0 ? _b : '';
+    if (tag.includes(splitChar))
+        tag = '';
+    return {
+        name,
+        tag,
+    };
+}
+/** Default `splitChar` is "#".  */
+export function makeRiotId(riotId, 
+/** @default '#' */
+splitChar = '#') {
+    return riotId.name + splitChar + riotId.tag;
+}
+/** Default `splitChar` is "#".  */
+export function validateRiotId(riotId, 
+/** @default '#' */
+splitChar = '#') {
+    const id = splitRiotId(riotId, splitChar);
+    if (id.name == '' || id.name.length > maxRiotGameNameCharCount)
+        return false;
+    if (id.tag == '' || id.tag.length > maxRiotTaglineCharCount)
+        return false;
+    return true;
+}

package/dist/helpers/rune.d.ts

@@ -0,0 +1,36 @@
+import { RuneId, RuneKey, RuneName, RuneTreeId, RuneTreeKey, RuneTreeName, RuneTrees, Runes, StatRuneId, StatRuneName, StatRunes, StatRunesInSlot, StatRunesInSlotArr, statRuneNames } from '../objects/generated/Runes';
+import { MergeKeys } from './type';
+/** Get a rune by its **id**, **key**, or **name**. */
+export declare function getRune(id_key_name: RuneId | RuneKey | RuneName): typeof Runes[keyof typeof Runes];
+type StatRune = MergeKeys<typeof StatRunes[keyof typeof StatRunes]>;
+type StatRuneInSlot = MergeKeys<typeof StatRunesInSlotArr[number]>;
+type SlotOfStatRune<T> = T extends StatRuneId ? keyof typeof StatRunesInSlot[T] : T extends StatRuneName ? keyof typeof StatRunesInSlot[typeof statRuneNames[T]] : undefined;
+/**
+ * Get a stat rune by its **id** or **name**.
+ *
+ * ---
+ * Optionally, receive a `horizontal` and `slot` property in the stat rune object
+ * by providing a value for the secondary function parameter `slot`.
+ * `horizontal` provides ids of other stat runes that are in the same row as gotten stat rune.
+ */
+export declare function getStatRune(id_name: StatRuneId | StatRuneName): StatRune;
+/**
+ * Get a stat rune by its **id** or **name**.
+ *
+ * ---
+ * Optionally, receive a `horizontal` and `slot` property in the stat rune object
+ * by providing a value for the secondary function parameter `slot`.
+ * `horizontal` provides ids of other stat runes that are in the same row as gotten stat rune.
+ */
+export declare function getStatRune<T extends StatRuneId | StatRuneName, S extends SlotOfStatRune<T>>(id_name: T, slot?: S): StatRuneInSlot;
+/** Get a rune tree by its **id**, **key**, or **name**. */
+export declare function getRuneTree(id_key_name: RuneTreeId | RuneTreeKey | RuneTreeName): typeof RuneTrees[keyof typeof RuneTrees];
+export declare function isRuneId(id: number | null | undefined): id is RuneId;
+export declare function isRuneKey(key: string | null | undefined): key is RuneKey;
+export declare function isRuneName(name: string | null | undefined): name is RuneName;
+export declare function isStatRuneId(id: number | null | undefined): id is StatRuneId;
+export declare function isStatRuneName(name: string | null | undefined): name is StatRuneName;
+export declare function isRuneTreeId(id: number | null | undefined): id is RuneTreeId;
+export declare function isRuneTreeKey(key: string | null | undefined): key is RuneTreeKey;
+export declare function isRuneTreeName(name: string | null | undefined): name is RuneTreeName;
+export {};

package/dist/helpers/rune.js

@@ -0,0 +1,70 @@
+import { RuneTrees, Runes, StatRunes, StatRunesInSlot, runeKeys, runeNames, runeTreeKeys, runeTreeNames, statRuneNames, } from '../objects/generated/Runes';
+/** Get a rune by its **id**, **key**, or **name**. */
+export function getRune(id_key_name) {
+    if (typeof id_key_name == 'number')
+        return Runes[id_key_name];
+    if (isRuneKey(id_key_name))
+        return Runes[runeKeys[id_key_name]];
+    return Runes[runeNames[id_key_name]];
+}
+export function getStatRune(id_name, slot) {
+    const statRuneSlot = slot;
+    if (typeof id_name == 'number') {
+        const statRuneId = id_name;
+        if (statRuneSlot == null) {
+            return StatRunes[statRuneId];
+        }
+        else {
+            const x = StatRunesInSlot[statRuneId];
+            if (statRuneSlot in StatRunesInSlot[statRuneId])
+                return StatRunesInSlot[statRuneId][statRuneSlot];
+            console.warn(`ended up with empty object while getting stat rune`);
+            return {}; // should not reach
+        }
+    }
+    else {
+        const statRuneName = id_name;
+        if (statRuneSlot == null) {
+            return StatRunes[statRuneNames[statRuneName]];
+        }
+        else {
+            const statRuneId = statRuneNames[statRuneName];
+            if (statRuneSlot in StatRunesInSlot[statRuneId])
+                return StatRunesInSlot[statRuneId][statRuneSlot];
+            console.warn(`ended up with empty object while getting stat rune`);
+            return {}; // should not reach
+        }
+    }
+}
+/** Get a rune tree by its **id**, **key**, or **name**. */
+export function getRuneTree(id_key_name) {
+    if (typeof id_key_name == 'number')
+        return RuneTrees[id_key_name];
+    if (isRuneTreeKey(id_key_name))
+        return RuneTrees[runeTreeKeys[id_key_name]];
+    return RuneTrees[runeTreeNames[id_key_name]];
+}
+export function isRuneId(id) {
+    return typeof id == 'number' && id in Runes;
+}
+export function isRuneKey(key) {
+    return typeof key == 'string' && key in runeKeys;
+}
+export function isRuneName(name) {
+    return typeof name == 'string' && name in runeNames;
+}
+export function isStatRuneId(id) {
+    return typeof id == 'number' && id in StatRunes;
+}
+export function isStatRuneName(name) {
+    return typeof name == 'string' && name in statRuneNames;
+}
+export function isRuneTreeId(id) {
+    return typeof id == 'number' && id in RuneTrees;
+}
+export function isRuneTreeKey(key) {
+    return typeof key == 'string' && key in runeTreeKeys;
+}
+export function isRuneTreeName(name) {
+    return typeof name == 'string' && name in runeTreeNames;
+}

package/dist/helpers/spell.d.ts

@@ -0,0 +1,6 @@
+import { SpellId, SpellKey, SpellName, Spells } from '../objects/generated/Spells';
+/** Get a summoner spell by its **id**, **key** or **name**. */
+export declare function getSpell(id_key_name: SpellId | SpellKey | SpellName): typeof Spells[keyof typeof Spells];
+export declare function isSpellId(id: number | null | undefined): id is SpellId;
+export declare function isSpellKey(key: string | null | undefined): key is SpellKey;
+export declare function isSpellName(name: string | null | undefined): name is SpellName;

package/dist/helpers/spell.js

@@ -0,0 +1,18 @@
+import { spellKeys, spellNames, Spells, } from '../objects/generated/Spells';
+/** Get a summoner spell by its **id**, **key** or **name**. */
+export function getSpell(id_key_name) {
+    if (typeof id_key_name == 'number')
+        return Spells[id_key_name];
+    if (isSpellKey(id_key_name))
+        return Spells[spellKeys[id_key_name]];
+    return Spells[spellNames[id_key_name]];
+}
+export function isSpellId(id) {
+    return typeof id == 'number' && id in Spells;
+}
+export function isSpellKey(key) {
+    return typeof key == 'string' && key in spellKeys;
+}
+export function isSpellName(name) {
+    return typeof name == 'string' && name in spellNames;
+}

package/dist/helpers/type.d.ts

@@ -0,0 +1,3 @@
+export type MergeKeys<T> = {
+    [K in keyof T]: T[K] extends infer U ? U : never;
+};

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+export { lol } from './lol';
+export { Patch } from './Patch';
+export * from './constants/custom';
+export * from './constants/events';
+export * from './constants/history';
+export * from './constants/leagues';
+export * from './constants/locales';
+export * from './constants/participants';
+export { ItemSrTypes } from './enums/ItemSrTypes';
+export { StatRuneSlots } from './enums/StatRuneSlots';
+export { getChampion, isChampionId, isChampionKey, isChampionName, } from './helpers/champion';
+export { getItem, isStarterItem, isBasicItem, isEpicItem, isLegendaryItem, isTrinketItem, isBootsItem, isConsumableItem, isItemAvailableOnMap, isItemId, isItemName, } from './helpers/item';
+export type { RiotId } from './helpers/riotId';
+export { makeRiotId, splitRiotId, validateRiotId, } from './helpers/riotId';
+export { getRune, getStatRune, getRuneTree, isRuneId, isRuneKey, isRuneName, isStatRuneId, isStatRuneName, isRuneTreeId, isRuneTreeKey, isRuneTreeName, } from './helpers/rune';
+export { getSpell, isSpellId, isSpellKey, isSpellName, } from './helpers/spell';
+export type { MapId, MapTitle } from './objects/Maps';
+export { MapsArr as Maps, getMap, isMapId, isMapTitle } from './objects/Maps';
+export type { QueueId, QueueTitle } from './objects/Queues';
+export { QueuesArr as Queues, isQueueId, isQueueTitle, getQueue, } from './objects/Queues';
+export type { Platform, Region } from './objects/Regions';
+export { RegionsArr as Regions, getRegion, isPlatform, isRegion, } from './objects/Regions';
+export { ChampionsArr as Champions } from './objects/generated/Champions';
+export type { ChampionId, ChampionKey, ChampionName, } from './objects/generated/Champions';
+export { ItemsArr as Items } from './objects/generated/Items';
+export type { ItemId, ItemName, } from './objects/generated/Items';
+export { RunesArr as Runes, StatRunesArr as StatRunes, RuneTreesArr as RuneTrees, } from './objects/generated/Runes';
+export type { RuneId, RuneKey, RuneName, StatRuneId, StatRuneName, RuneTreeId, RuneTreeKey, RuneTreeName, } from './objects/generated/Runes';
+export { SpellsArr as Spells } from './objects/generated/Spells';
+export type { SpellId, SpellKey, SpellName, } from './objects/generated/Spells';

package/dist/index.js

@@ -0,0 +1,27 @@
+// # .
+export { lol } from './lol';
+export { Patch } from './Patch';
+// # constants
+export * from './constants/custom';
+export * from './constants/events';
+export * from './constants/history';
+export * from './constants/leagues';
+export * from './constants/locales';
+export * from './constants/participants';
+// # enums
+export { ItemSrTypes } from './enums/ItemSrTypes';
+export { StatRuneSlots } from './enums/StatRuneSlots';
+// # helpers
+export { getChampion, isChampionId, isChampionKey, isChampionName, } from './helpers/champion';
+export { getItem, isStarterItem, isBasicItem, isEpicItem, isLegendaryItem, isTrinketItem, isBootsItem, isConsumableItem, isItemAvailableOnMap, isItemId, isItemName, } from './helpers/item';
+export { makeRiotId, splitRiotId, validateRiotId, } from './helpers/riotId';
+export { getRune, getStatRune, getRuneTree, isRuneId, isRuneKey, isRuneName, isStatRuneId, isStatRuneName, isRuneTreeId, isRuneTreeKey, isRuneTreeName, } from './helpers/rune';
+export { getSpell, isSpellId, isSpellKey, isSpellName, } from './helpers/spell';
+export { MapsArr as Maps, getMap, isMapId, isMapTitle } from './objects/Maps';
+export { QueuesArr as Queues, isQueueId, isQueueTitle, getQueue, } from './objects/Queues';
+export { RegionsArr as Regions, getRegion, isPlatform, isRegion, } from './objects/Regions';
+// ## generated
+export { ChampionsArr as Champions } from './objects/generated/Champions';
+export { ItemsArr as Items } from './objects/generated/Items';
+export { RunesArr as Runes, StatRunesArr as StatRunes, RuneTreesArr as RuneTrees, } from './objects/generated/Runes';
+export { SpellsArr as Spells } from './objects/generated/Spells';