@ianlucas/cs2-lib 5.0.0-rc.17 → 5.0.0-rc.18

package/dist/economy.d.ts

@@ -22,13 +22,13 @@ export declare class CS2EconomyInstance {
     safeValidateWear(wear?: number, item?: CS2EconomyItem): boolean;
     validateSeed(seed?: number, item?: CS2EconomyItem): boolean;
     safeValidateSeed(seed?: number, item?: CS2EconomyItem): boolean;
-    trimNametag(nametag?: string): string | undefined;
-    validateNametag(nametag?: string, item?: CS2EconomyItem): boolean;
-    safeValidateNametag(nametag?: string, item?: CS2EconomyItem): boolean;
-    requireNametag(nametag?: string, item?: CS2EconomyItem): boolean;
-    safeRequireNametag(nametag?: string, item?: CS2EconomyItem): boolean;
-    validateStatTrak(stattrak?: number, item?: CS2EconomyItem): boolean;
-    safeValidateStatTrak(stattrak?: number, item?: CS2EconomyItem): boolean;
+    trimNametag(nameTag?: string): string | undefined;
+    validateNametag(nameTag?: string, item?: CS2EconomyItem): boolean;
+    safeValidateNametag(nameTag?: string, item?: CS2EconomyItem): boolean;
+    requireNametag(nameTag?: string, item?: CS2EconomyItem): boolean;
+    safeRequireNametag(nameTag?: string, item?: CS2EconomyItem): boolean;
+    validateStatTrak(statTrak?: number, item?: CS2EconomyItem): boolean;
+    safeValidateStatTrak(statTrak?: number, item?: CS2EconomyItem): boolean;
     getWearFromValue(value: number): CS2ItemWearValues;
     getStickerCategories(): string[];
     getStickers(): CS2EconomyItem[];
@@ -139,6 +139,8 @@ export declare class CS2EconomyItem implements Interface<Omit<CS2Item, "contents
     isInContainers(): boolean;
     isInDisplay(): boolean;
     isHoldable(): boolean;
+    getMinimumWear(): number;
+    getMaximumWear(): number;
     groupContents(): Record<string, CS2EconomyItem[]>;
     listContents(hideSpecials?: boolean): CS2EconomyItem[];
     unlockContainer(): CS2UnlockedItem;

package/dist/economy.js

@@ -80,38 +80,38 @@ export class CS2EconomyInstance {
     safeValidateSeed(seed, item) {
         return safe(() => this.validateSeed(seed, item));
     }
-    trimNametag(nametag) {
-        const trimmed = nametag?.trim();
+    trimNametag(nameTag) {
+        const trimmed = nameTag?.trim();
         return trimmed === "" ? undefined : trimmed;
     }
-    validateNametag(nametag, item) {
-        if (nametag !== undefined) {
+    validateNametag(nameTag, item) {
+        if (nameTag !== undefined) {
             assert(item === undefined || item.hasNametag());
-            assert(nametag[0] !== " " && CS2_NAMETAG_RE.test(nametag));
+            assert(nameTag[0] !== " " && CS2_NAMETAG_RE.test(nameTag));
         }
         return true;
     }
-    safeValidateNametag(nametag, item) {
-        return safe(() => this.validateNametag(nametag, item));
+    safeValidateNametag(nameTag, item) {
+        return safe(() => this.validateNametag(nameTag, item));
     }
-    requireNametag(nametag, item) {
-        assert(nametag === undefined || nametag.trim().length > 0);
-        return this.validateNametag(nametag, item);
+    requireNametag(nameTag, item) {
+        assert(nameTag === undefined || nameTag.trim().length > 0);
+        return this.validateNametag(nameTag, item);
     }
-    safeRequireNametag(nametag, item) {
-        return safe(() => this.requireNametag(nametag, item));
+    safeRequireNametag(nameTag, item) {
+        return safe(() => this.requireNametag(nameTag, item));
     }
-    validateStatTrak(stattrak, item) {
-        if (stattrak === undefined) {
+    validateStatTrak(statTrak, item) {
+        if (statTrak === undefined) {
             return true;
         }
         assert(item === undefined || item.hasStatTrak());
-        assert(Number.isInteger(stattrak));
-        assert(stattrak >= CS2_MIN_STATTRAK && stattrak <= CS2_MAX_STATTRAK);
+        assert(Number.isInteger(statTrak));
+        assert(statTrak >= CS2_MIN_STATTRAK && statTrak <= CS2_MAX_STATTRAK);
         return true;
     }
-    safeValidateStatTrak(stattrak, item) {
-        return safe(() => this.validateStatTrak(stattrak, item));
+    safeValidateStatTrak(statTrak, item) {
+        return safe(() => this.validateStatTrak(statTrak, item));
     }
     getWearFromValue(value) {
         switch (true) {
@@ -431,6 +431,12 @@ export class CS2EconomyItem {
     isHoldable() {
         return CS2_WEARABLE_ITEMS.includes(this.type);
     }
+    getMinimumWear() {
+        return this.wearMin ?? CS2_MIN_WEAR;
+    }
+    getMaximumWear() {
+        return this.wearMax ?? CS2_MAX_WEAR;
+    }
     groupContents() {
         const items = {};
         const specials = this.specials;

package/dist/inventory.d.ts

@@ -56,7 +56,7 @@ export declare class CS2Inventory {
     add(item: CS2BaseInventoryItem): this;
     private addInventoryItem;
     addWithNametag(nameTagUid: number, id: number, nameTag: string): this;
-    addWithSticker(stickerUid: number, id: number, stickerIndex: number): this;
+    addWithSticker(stickerUid: number, id: number, slot: number): this;
     edit(itemUid: number, properties: Partial<CS2BaseInventoryItem>): this;
     equip(itemUid: number, team?: CS2TeamValues): this;
     unequip(uid: number, team?: CS2TeamValues): this;
@@ -71,8 +71,8 @@ export declare class CS2Inventory {
     getStorageUnitItems(storageUid: number): CS2InventoryItem[];
     depositToStorageUnit(storageUid: number, depositUids: number[]): this;
     retrieveFromStorageUnit(storageUid: number, retrieveUids: number[]): this;
-    applyItemSticker(targetUid: number, stickerUid: number, stickerIndex: number): this;
-    scrapeItemSticker(targetUid: number, stickerIndex: number): this;
+    applyItemSticker(targetUid: number, stickerUid: number, slot: number): this;
+    scrapeItemSticker(targetUid: number, slot: number): this;
     applyItemPatch(targetUid: number, patchUid: number, patchIndex: number): this;
     removeItemPatch(targetUid: number, patchIndex: number): this;
     incrementItemStatTrak(targetUid: number): this;
@@ -114,5 +114,7 @@ export declare class CS2InventoryItem extends CS2EconomyItem implements Interfac
     allPatches(): [number, number | undefined][];
     somePatches(): [number, number][];
     getStickersCount(): number;
+    getWear(): number;
+    getStickerWear(slot: number): number;
     asBase(): CS2BaseInventoryItem;
 }

package/dist/inventory.js

@@ -2,7 +2,7 @@
  *  Copyright (c) Ian Lucas. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import { CS2_MAX_PATCHES, CS2_MAX_STATTRAK, CS2_MAX_STICKERS, CS2_MAX_STICKER_WEAR, CS2_MAX_WEAR, CS2_MIN_STICKER_WEAR, CS2_STICKER_WEAR_FACTOR } from "./economy-constants.js";
+import { CS2_MAX_PATCHES, CS2_MAX_STATTRAK, CS2_MAX_STICKERS, CS2_MAX_STICKER_WEAR, CS2_MAX_WEAR, CS2_MIN_STICKER_WEAR, CS2_MIN_WEAR, CS2_STICKER_WEAR_FACTOR } from "./economy-constants.js";
 import { CS2ItemType } from "./economy-types.js";
 import { CS2Economy, CS2EconomyItem } from "./economy.js";
 import { resolveInventoryData } from "./inventory-upgrader.js";
@@ -132,12 +132,12 @@ export class CS2Inventory {
         this.add({ id, nameTag });
         return this;
     }
-    addWithSticker(stickerUid, id, stickerIndex) {
+    addWithSticker(stickerUid, id, slot) {
         const sticker = this.get(stickerUid).expectSticker();
         this.items.delete(stickerUid);
         this.add({
             id,
-            stickers: { [stickerIndex]: { id: sticker.id } }
+            stickers: { [slot]: { id: sticker.id } }
         });
         return this;
     }
@@ -274,27 +274,27 @@ export class CS2Inventory {
         item.updatedAt = getTimestamp();
         return this;
     }
-    applyItemSticker(targetUid, stickerUid, stickerIndex) {
-        assert(stickerIndex >= 0 && stickerIndex <= CS2_MAX_STICKERS - 1);
+    applyItemSticker(targetUid, stickerUid, slot) {
+        assert(slot >= 0 && slot <= CS2_MAX_STICKERS - 1);
         const target = this.get(targetUid);
         const sticker = this.get(stickerUid);
         assert(target.hasStickers());
         sticker.expectSticker();
         target.stickers ??= new Map();
-        assert(target.stickers.get(stickerIndex) === undefined);
-        target.stickers.set(stickerIndex, { id: sticker.id });
+        assert(target.stickers.get(slot) === undefined);
+        target.stickers.set(slot, { id: sticker.id });
         target.updatedAt = getTimestamp();
         this.items.delete(stickerUid);
         return this;
     }
-    scrapeItemSticker(targetUid, stickerIndex) {
+    scrapeItemSticker(targetUid, slot) {
         const target = this.get(targetUid);
         assert(target.stickers !== undefined);
-        const sticker = ensure(target.stickers.get(stickerIndex));
+        const sticker = ensure(target.stickers.get(slot));
         const wear = sticker.wear ?? 0;
         const nextWear = float(wear + CS2_STICKER_WEAR_FACTOR);
         if (nextWear > CS2_MAX_WEAR) {
-            target.stickers.delete(stickerIndex);
+            target.stickers.delete(slot);
             if (target.stickers.size === 0) {
                 target.stickers = undefined;
             }
@@ -399,18 +399,18 @@ export class CS2InventoryItem extends CS2EconomyItem {
     wear;
     assign({ patches, stickers, storage }) {
         if (patches !== undefined) {
-            this.patches = new Map(Object.entries(patches).map(([key, item]) => [parseInt(key, 10), item]));
+            this.patches = new Map(Object.entries(patches).map(([key, value]) => [parseInt(key, 10), value]));
         }
         if (stickers !== undefined) {
-            this.stickers = new Map(Object.entries(stickers).map(([key, item]) => [parseInt(key, 10), item]));
+            this.stickers = new Map(Object.entries(stickers).map(([key, value]) => [parseInt(key, 10), value]));
         }
         if (storage !== undefined) {
             assert(this.isStorageUnit());
-            this.storage = new Map(Object.entries(storage).map(([key, item]) => {
-                const storedEconomyItem = this.economy.getById(item.id);
-                assert(item.storage === undefined);
+            this.storage = new Map(Object.entries(storage).map(([key, value]) => {
+                const storedEconomyItem = this.economy.getById(value.id);
+                assert(value.storage === undefined);
                 const uid = parseInt(key, 10);
-                return [uid, new CS2InventoryItem(this.inventory, uid, item, storedEconomyItem)];
+                return [uid, new CS2InventoryItem(this.inventory, uid, value, storedEconomyItem)];
             }));
         }
     }
@@ -453,6 +453,12 @@ export class CS2InventoryItem extends CS2EconomyItem {
     getStickersCount() {
         return this.stickers?.size ?? 0;
     }
+    getWear() {
+        return this.wear ?? this.wearMin ?? CS2_MIN_WEAR;
+    }
+    getStickerWear(slot) {
+        return this.stickers?.get(slot)?.wear ?? 0;
+    }
     asBase() {
         return {
             containerId: this.containerId,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ianlucas/cs2-lib",
-    "version": "5.0.0-rc.17",
+    "version": "5.0.0-rc.18",
     "description": "A TypeScript library for manipulating Counter-Strike 2 data",
     "license": "MIT",
     "author": "Ian Lucas",