@ianlucas/cs2-lib 5.0.0-rc.1 → 5.0.0-rc.11

package/dist/economy-constants.d.ts

@@ -22,7 +22,6 @@ export declare const CS2_MIN_STICKER_WEAR = 0;
 export declare const CS2_MAX_STICKER_WEAR = 0.9;
 export declare const CS2_MAX_STICKERS = 5;
 export declare const CS2_MAX_PATCHES = 5;
-export declare const CS2_NONE = 0;
 export declare const CS2_STICKER_WEAR_FACTOR = 0.1;
 export declare const CS2_WEAR_FACTOR = 0.000001;
 export declare const CS2_NAMETAG_RE: RegExp;

package/dist/economy-constants.js

@@ -26,7 +26,6 @@ export const CS2_MIN_STICKER_WEAR = 0;
 export const CS2_MAX_STICKER_WEAR = 0.9;
 export const CS2_MAX_STICKERS = 5;
 export const CS2_MAX_PATCHES = 5;
-export const CS2_NONE = 0;
 export const CS2_STICKER_WEAR_FACTOR = 0.1;
 export const CS2_WEAR_FACTOR = 0.000001;
 export const CS2_NAMETAG_RE = /^[A-Za-z0-9`!@#$%^&*-+=(){}\[\]\/\|\\,.?:;'_\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\s]{0,20}$/u;

package/dist/economy-types.d.ts

@@ -1,5 +1,5 @@
-import { CS2RarityColorValues } from "./economy-container.js";
-import { EnumValues } from "./utils.js";
+import type { CS2RarityColorValues, CS2RaritySoundNameValues } from "./economy-container.js";
+import type { EnumValues } from "./utils.js";
 export declare const CS2ItemTeam: {
     readonly T: 0;
     readonly CT: 1;
@@ -23,11 +23,11 @@ export declare const CS2ItemType: {
 };
 export type CS2ItemTypeValues = EnumValues<typeof CS2ItemType>;
 export declare const CS2ItemWear: {
-    readonly FactoryNew: 0;
-    readonly MinimalWear: 1;
-    readonly FieldTested: 2;
-    readonly WellWorn: 3;
-    readonly BattleScarred: 4;
+    readonly FactoryNew: "FN";
+    readonly MinimalWear: "MW";
+    readonly FieldTested: "FT";
+    readonly WellWorn: "WW";
+    readonly BattleScarred: "BS";
 };
 export type CS2ItemWearValues = EnumValues<typeof CS2ItemWear>;
 export declare const CS2ContainerType: {
@@ -75,5 +75,16 @@ export interface CS2ItemLocalization {
     name: string;
     tournamentDesc?: string | undefined;
 }
-export type CS2ItemLocalizationMap = Record<number, CS2ItemLocalization | undefined>;
+export type CS2ItemLocalizationMap = Record<string, CS2ItemLocalization | undefined>;
 export type CS2ItemLocalizationByLanguage = Record<string, CS2ItemLocalizationMap>;
+export interface CS2UnlockedItem {
+    attributes: {
+        containerId: number;
+        seed: number | undefined;
+        statTrak: number | undefined;
+        wear: number | undefined;
+    };
+    id: number;
+    rarity: CS2RaritySoundNameValues;
+    special: boolean;
+}

package/dist/economy-types.js

@@ -23,11 +23,11 @@ export const CS2ItemType = {
     Weapon: "weapon"
 };
 export const CS2ItemWear = {
-    FactoryNew: 0,
-    MinimalWear: 1,
-    FieldTested: 2,
-    WellWorn: 3,
-    BattleScarred: 4
+    FactoryNew: "FN",
+    MinimalWear: "MW",
+    FieldTested: "FT",
+    WellWorn: "WW",
+    BattleScarred: "BS"
 };
 export const CS2ContainerType = {
     WeaponCase: 0,

package/dist/economy.d.ts

@@ -1,5 +1,5 @@
-import { CS2RarityColorValues, CS2RaritySoundNameValues } from "./economy-container.js";
-import { CS2ContainerTypeValues, CS2Item, CS2ItemLocalization, CS2ItemLocalizationMap, CS2ItemTeamValues, CS2ItemTypeValues, CS2ItemWearValues } from "./economy-types.js";
+import { CS2RarityColorValues } from "./economy-container.js";
+import { CS2ContainerTypeValues, CS2Item, CS2ItemLocalization, CS2ItemLocalizationMap, CS2ItemTeamValues, CS2ItemTypeValues, CS2ItemWearValues, CS2UnlockedItem } from "./economy-types.js";
 import { CS2TeamValues } from "./teams.js";
 import { Interface } from "./utils.js";
 type CS2EconomyItemPredicate = Partial<CS2EconomyItem> & {
@@ -37,12 +37,15 @@ export declare class CS2EconomyInstance {
     resolveContainerSpecialsImage(baseUrl: string, item: number | CS2EconomyItem): string;
     validateContainerAndKey(containerItem: number | CS2EconomyItem, keyItem?: number | CS2EconomyItem): boolean;
     safeValidateContainerAndKey(containerItem: number | CS2EconomyItem, keyItem?: number | CS2EconomyItem): boolean;
-    validateUnlockedItem(item: number | CS2EconomyItem, { id }: ReturnType<InstanceType<typeof CS2EconomyItem>["unlock"]>): void;
+    validateUnlockedItem(item: number | CS2EconomyItem, { id }: ReturnType<InstanceType<typeof CS2EconomyItem>["unlockContainer"]>): void;
 }
 export declare class CS2EconomyItem implements Interface<Omit<CS2Item, "contents" | "specials" | "teams"> & CS2ItemLocalization & {
     contents: CS2EconomyItem[] | undefined;
     teams: CS2TeamValues[] | undefined;
 }> {
+    economy: CS2EconomyInstance;
+    item: CS2Item;
+    language: CS2ItemLocalization;
     altName: string | undefined;
     base: boolean | undefined;
     baseId: number | undefined;
@@ -74,10 +77,9 @@ export declare class CS2EconomyItem implements Interface<Omit<CS2Item, "contents
     wearMax: number | undefined;
     wearMin: number | undefined;
     private _contents;
-    private _economy;
     private _specials;
     private _teams;
-    constructor(economyInstance: CS2EconomyInstance, item: CS2Item, language: CS2ItemLocalization);
+    constructor(economy: CS2EconomyInstance, item: CS2Item, language: CS2ItemLocalization);
     set contents(value: number[] | undefined);
     get contents(): CS2EconomyItem[];
     get parent(): CS2EconomyItem | undefined;
@@ -87,6 +89,7 @@ export declare class CS2EconomyItem implements Interface<Omit<CS2Item, "contents
     get specials(): CS2EconomyItem[] | undefined;
     set teams(value: CS2ItemTeamValues);
     get teams(): CS2TeamValues[] | undefined;
+    isStub(): boolean;
     isC4(): boolean;
     isAgent(): boolean;
     isSticker(): boolean;
@@ -118,17 +121,7 @@ export declare class CS2EconomyItem implements Interface<Omit<CS2Item, "contents
     isSouvenirCase(): boolean;
     groupContents(): Record<string, CS2EconomyItem[]>;
     listContents(hideSpecials?: boolean): CS2EconomyItem[];
-    unlock(): {
-        attributes: {
-            containerId: number;
-            seed: number | undefined;
-            statTrak: number | undefined;
-            wear: number | undefined;
-        };
-        id: number;
-        rarity: CS2RaritySoundNameValues;
-        special: boolean;
-    };
+    unlockContainer(): CS2UnlockedItem;
 }
 export declare const CS2Economy: CS2EconomyInstance;
 export {};

package/dist/economy.js

@@ -27,9 +27,6 @@ export class CS2EconomyInstance {
         this.stickers.clear();
         this.itemsAsArray = [];
         for (const item of items) {
-            if (item.type === CS2ItemType.Stub) {
-                continue;
-            }
             const economyItem = new CS2EconomyItem(this, item, ensure(language[item.id]));
             this.items.set(item.id, economyItem);
             if (economyItem.isSticker()) {
@@ -190,6 +187,9 @@ export class CS2EconomyInstance {
     }
 }
 export class CS2EconomyItem {
+    economy;
+    item;
+    language;
     altName;
     base;
     baseId;
@@ -221,27 +221,32 @@ export class CS2EconomyItem {
     wearMax;
     wearMin;
     _contents;
-    _economy;
     _specials;
     _teams;
-    constructor(economyInstance, item, language) {
-        this._economy = economyInstance;
+    constructor(economy, item, language) {
+        this.economy = economy;
+        this.item = item;
+        this.language = language;
         Object.assign(this, item);
         Object.assign(this, language);
         assert(typeof this.id === "number");
+        assert(typeof this.id === "number");
         assert(this.name);
-        assert(this.rarity);
         assert(this.type);
+        if (item.type !== CS2ItemType.Stub) {
+            // @todo: add a rarity to stubs.
+            assert(this.rarity);
+        }
     }
     set contents(value) {
         this._contents = value;
     }
     get contents() {
         this.expectContainer();
-        return ensure(this._contents).map((id) => this._economy.get(id));
+        return ensure(this._contents).map((id) => this.economy.get(id));
     }
     get parent() {
-        return this.baseId !== undefined ? this._economy.get(this.baseId) : undefined;
+        return this.baseId !== undefined ? this.economy.get(this.baseId) : undefined;
     }
     get rawContents() {
         return this._contents;
@@ -254,7 +259,7 @@ export class CS2EconomyItem {
     }
     get specials() {
         this.expectContainer();
-        return this._specials?.map((id) => this._economy.get(id));
+        return this._specials?.map((id) => this.economy.get(id));
     }
     set teams(value) {
         this._teams = value;
@@ -271,6 +276,9 @@ export class CS2EconomyItem {
                 return undefined;
         }
     }
+    isStub() {
+        return this.type === CS2ItemType.Stub;
+    }
     isC4() {
         return this.category === "c4";
     }
@@ -395,7 +403,7 @@ export class CS2EconomyItem {
                 (CS2RarityColorOrder[b.rarity] ?? CS2_RARITY_COLOR_DEFAULT));
         });
     }
-    unlock() {
+    unlockContainer() {
         // @see https://www.csgo.com.cn/news/gamebroad/20170911/206155.shtml
         const contents = this.groupContents();
         const keys = Object.keys(contents);

package/dist/index.d.ts

@@ -2,7 +2,6 @@ export * from "./economy-constants.js";
 export * from "./economy-container.js";
 export * from "./economy-types.js";
 export * from "./economy.js";
-export * from "./inventory-instance.js";
 export * from "./inventory.js";
 export * from "./items.js";
 export * from "./keyvalues.js";

package/dist/index.js

@@ -6,7 +6,6 @@ export * from "./economy-constants.js";
 export * from "./economy-container.js";
 export * from "./economy-types.js";
 export * from "./economy.js";
-export * from "./inventory-instance.js";
 export * from "./inventory.js";
 export * from "./items.js";
 export * from "./keyvalues.js";

package/dist/inventory-upgrader.d.ts

@@ -0,0 +1,2 @@
+import { CS2InventoryData } from "./inventory.js";
+export declare function resolveInventoryData(stringValue: string | null | undefined): CS2InventoryData | undefined;

package/dist/inventory-upgrader.js

@@ -0,0 +1,76 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Ian Lucas. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { CS2_INVENTORY_VERSION } from "./inventory.js";
+const upgrades = {
+    1: (data) => {
+        function walkV0(v0) {
+            const v1 = {};
+            for (let [key, value] of Object.entries(v0)) {
+                switch (key) {
+                    case "caseid":
+                        key = "containerId";
+                        break;
+                    case "nametag":
+                        key = "nameTag";
+                        break;
+                    case "stattrak":
+                        key = "statTrak";
+                        break;
+                    case "stickers":
+                        value =
+                            value !== undefined
+                                ? Object.fromEntries(value
+                                    .filter((stickerId) => stickerId !== 0)
+                                    .map((stickerId, slot) => [
+                                    slot,
+                                    {
+                                        id: stickerId,
+                                        wear: v0.stickerswear?.[slot] || undefined
+                                    }
+                                ]))
+                                : undefined;
+                        break;
+                    case "stickerswear":
+                        continue;
+                    case "storage":
+                        value =
+                            value !== undefined
+                                ? Object.fromEntries(value.map((v0) => [v0.uid, walkV0(v0)]))
+                                : undefined;
+                        break;
+                    case "uid":
+                        continue;
+                    case "updatedat":
+                        key = "updatedAt";
+                        break;
+                }
+                v1[key] = value;
+            }
+            return v1;
+        }
+        return {
+            items: Object.fromEntries(data.map((v0) => [v0.uid, walkV0(v0)])),
+            version: 1
+        };
+    }
+};
+export function resolveInventoryData(stringValue) {
+    try {
+        if (!stringValue) {
+            return undefined;
+        }
+        let value = JSON.parse(stringValue);
+        const currentVersion = value.version ?? 0;
+        for (let i = currentVersion + 1; i <= CS2_INVENTORY_VERSION; i++) {
+            if (upgrades[i]) {
+                value = upgrades[i](value);
+            }
+        }
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/inventory.d.ts

@@ -1,4 +1,117 @@
-import { CS2InventoryData } from "./inventory-instance.js";
+import { CS2ItemTypeValues, CS2UnlockedItem } from "./economy-types.js";
+import { CS2EconomyInstance, CS2EconomyItem } from "./economy.js";
+import { CS2TeamValues } from "./teams.js";
+import { Interface, MapValue } from "./utils.js";
+export interface CS2BaseInventoryItem {
+    containerId?: number;
+    equipped?: boolean;
+    equippedCT?: boolean;
+    equippedT?: boolean;
+    id: number;
+    nameTag?: string;
+    patches?: Record<number, number>;
+    seed?: number;
+    statTrak?: number;
+    stickers?: Record<number, {
+        id: number;
+        wear?: number;
+        x?: number;
+        y?: number;
+    }>;
+    storage?: Record<number, CS2BaseInventoryItem>;
+    updatedAt?: number;
+    wear?: number;
+}
+export interface CS2InventoryData {
+    items: Record<number, CS2BaseInventoryItem>;
+    version: number;
+}
+export interface CS2InventoryOptions {
+    maxItems: number;
+    storageUnitMaxItems: number;
+}
+export interface CS2InventorySpec extends CS2InventoryOptions {
+    economy: CS2EconomyInstance;
+    data: CS2InventoryData;
+}
+export declare const CS2_INVENTORY_VERSION = 1;
+export declare const CS2_INVENTORY_TIMESTAMP = 1707696138408;
+export declare const CS2_INVENTORY_EQUIPPABLE_ITEMS: CS2ItemTypeValues[];
+export declare function getTimestamp(): number;
+export declare function getNextUid(map: Map<number, unknown>): number;
 export declare class CS2Inventory {
-    static parse(stringValue: string | null | undefined): CS2InventoryData | undefined;
+    private economy;
+    private items;
+    readonly options: Readonly<CS2InventoryOptions>;
+    static parse(stringValue: string | undefined | null): CS2InventoryData | undefined;
+    constructor({ economy, data, maxItems, storageUnitMaxItems }?: Partial<CS2InventorySpec>);
+    private validateEquippable;
+    private validateStickers;
+    private validatePatches;
+    validateBaseInventoryItem({ id, nameTag, patches, seed, statTrak, stickers, wear }: CS2BaseInventoryItem): void;
+    private toInventoryItems;
+    private toBaseInventoryItems;
+    stringify(): string;
+    isFull(): boolean;
+    add(item: CS2BaseInventoryItem): this;
+    private addInventoryItem;
+    addWithNametag(nameTagUid: number, id: number, nameTag: string): this;
+    addWithSticker(stickerUid: number, id: number, stickerIndex: number): this;
+    edit(itemUid: number, properties: Partial<CS2BaseInventoryItem>): this;
+    equip(itemUid: number, team?: CS2TeamValues): this;
+    unequip(uid: number, team?: CS2TeamValues): this;
+    unlockContainer(unlockedItem: CS2UnlockedItem, containerUid: number, keyUid?: number): this;
+    renameItem(nameTagUid: number, renameableUid: number, nameTag?: string): this;
+    renameStorageUnit(storageUid: number, nameTag: string): this;
+    isStorageUnitFull(storageUid: number): boolean;
+    getStorageUnitSize(storageUid: number): number;
+    isStorageUnitFilled(storageUid: number): boolean;
+    canDepositToStorageUnit(storageUid: number, size?: number): boolean;
+    canRetrieveFromStorageUnit(storageUid: number, size?: number): boolean;
+    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;
+    applyItemPatch(targetUid: number, patchUid: number, patchIndex: number): this;
+    removeItemPatch(targetUid: number, patchIndex: number): this;
+    incrementItemStatTrak(targetUid: number): this;
+    swapItemsStatTrak(statTrakSwapToolUid: number, fromUid: number, toUid: number): this;
+    remove(uid: number): this;
+    removeAll(): this;
+    get(uid: number): CS2InventoryItem;
+    getAll(): CS2InventoryItem[];
+    getAllAsBase(): CS2BaseInventoryItem[];
+    setAll(items: Map<number, CS2InventoryItem>): this;
+    size(): number;
+    move(): CS2Inventory;
+}
+export declare class CS2InventoryItem extends CS2EconomyItem implements Interface<Omit<CS2BaseInventoryItem, "patches" | "stickers" | "storage">> {
+    private inventory;
+    uid: number;
+    containerId: number | undefined;
+    equipped: boolean | undefined;
+    equippedCT: boolean | undefined;
+    equippedT: boolean | undefined;
+    nameTag: string | undefined;
+    patches: Map<number, number> | undefined;
+    seed: number | undefined;
+    statTrak: number | undefined;
+    stickers: Map<number, {
+        id: number;
+        wear?: number;
+        x?: number;
+        y?: number;
+    }> | undefined;
+    storage: Map<number, CS2InventoryItem> | undefined;
+    updatedAt: number | undefined;
+    wear: number | undefined;
+    private assign;
+    constructor(inventory: CS2Inventory, uid: number, baseInventoryItem: CS2BaseInventoryItem, { economy, item, language }: CS2EconomyItem);
+    edit(...sources: Partial<CS2BaseInventoryItem>[]): void;
+    allStickers(): [number, MapValue<CS2InventoryItem["stickers"]> | undefined][];
+    someStickers(): [number, MapValue<CS2InventoryItem["stickers"]>][];
+    allPatches(): [number, number | undefined][];
+    somePatches(): [number, number][];
+    asBase(): CS2BaseInventoryItem;
 }