@nice2dev/game-engine 1.0.5 → 1.0.11

package/dist/cjs/inventory/InventorySystem.js

@@ -45,15 +45,14 @@ class InventoryManager {
         this.eventBus = bus;
     }
     emit(event) {
-        var _a;
-        (_a = this.eventBus) === null || _a === void 0 ? void 0 : _a.emit(`inventory:${event.type}`, event);
+        this.eventBus?.emit(`inventory:${event.type}`, event);
     }
     /* ── Item Definitions ───────────────────────────────────────── */
     registerItem(definition) {
         this.itemDefinitions.set(definition.id, definition);
     }
     registerItems(definitions) {
-        definitions.forEach(def => this.registerItem(def));
+        definitions.forEach((def) => this.registerItem(def));
     }
     getItemDefinition(itemId) {
         return this.itemDefinitions.get(itemId);
@@ -63,18 +62,17 @@ class InventoryManager {
     }
     /* ── Container Management ───────────────────────────────────── */
     createContainer(type, ownerId, options = {}) {
-        var _a, _b, _c, _d;
-        const id = (_a = options.id) !== null && _a !== void 0 ? _a : `container_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
-        const maxSlots = (_b = options.maxSlots) !== null && _b !== void 0 ? _b : this.config.defaultSlots;
+        const id = options.id ?? `container_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+        const maxSlots = options.maxSlots ?? this.config.defaultSlots;
         const container = {
             id,
             type,
-            name: (_c = options.name) !== null && _c !== void 0 ? _c : `${type} container`,
+            name: options.name ?? `${type} container`,
             ownerId,
             maxSlots,
             maxWeight: options.maxWeight,
             slots: Array.from({ length: maxSlots }, (_, i) => ({ index: i, item: null })),
-            currency: (_d = options.currency) !== null && _d !== void 0 ? _d : new Map(),
+            currency: options.currency ?? new Map(),
             allowedCategories: options.allowedCategories,
             disallowedCategories: options.disallowedCategories,
         };
@@ -86,26 +84,32 @@ class InventoryManager {
         return this.containers.get(containerId);
     }
     getContainersByOwner(ownerId) {
-        return Array.from(this.containers.values()).filter(c => c.ownerId === ownerId);
+        return Array.from(this.containers.values()).filter((c) => c.ownerId === ownerId);
     }
     destroyContainer(containerId) {
         const container = this.containers.get(containerId);
-        if (!container)
+        if (!container) {
             return false;
+        }
         this.containers.delete(containerId);
-        this.emit({ type: 'container:destroyed', containerId, ownerId: container.ownerId, timestamp: Date.now() });
+        this.emit({
+            type: 'container:destroyed',
+            containerId,
+            ownerId: container.ownerId,
+            timestamp: Date.now(),
+        });
         return true;
     }
     /* ── Item Instance Creation ─────────────────────────────────── */
     createItemInstance(itemId, count = 1, options = {}) {
-        var _a;
         const def = this.itemDefinitions.get(itemId);
-        if (!def)
+        if (!def) {
             return null;
+        }
         // Extract count from options to prevent override
         const { count: _ignoredCount, ...restOptions } = options;
         const instance = {
-            instanceId: (_a = restOptions.instanceId) !== null && _a !== void 0 ? _a : `item_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+            instanceId: restOptions.instanceId ?? `item_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
             itemId,
             count: Math.min(count, def.maxStack),
             durability: def.maxDurability,
@@ -116,24 +120,25 @@ class InventoryManager {
     }
     /* ── Basic Operations ───────────────────────────────────────── */
     addItem(containerId, itemId, count = 1, options = {}) {
-        var _a, _b, _c;
         const container = this.containers.get(containerId);
-        if (!container)
+        if (!container) {
             return null;
+        }
         const def = this.itemDefinitions.get(itemId);
-        if (!def)
+        if (!def) {
             return null;
+        }
         // Check category restrictions
         if (container.allowedCategories && !container.allowedCategories.includes(def.category)) {
             return null;
         }
-        if ((_a = container.disallowedCategories) === null || _a === void 0 ? void 0 : _a.includes(def.category)) {
+        if (container.disallowedCategories?.includes(def.category)) {
             return null;
         }
         // Check weight
         if (this.config.enableWeight && container.maxWeight !== undefined) {
             const currentWeight = this.getContainerWeight(containerId);
-            if (currentWeight + (def.weight * count) > container.maxWeight) {
+            if (currentWeight + def.weight * count > container.maxWeight) {
                 return null;
             }
         }
@@ -154,20 +159,23 @@ class InventoryManager {
                         count: toAdd,
                         timestamp: Date.now(),
                     });
-                    if (count <= 0)
+                    if (count <= 0) {
                         return slot.item;
+                    }
                 }
             }
         }
         // Find empty slot for remaining
         while (count > 0) {
-            const emptySlot = container.slots.find(s => !s.item && !s.locked);
-            if (!emptySlot)
-                return null; // No space
+            const emptySlot = container.slots.find((s) => !s.item && !s.locked);
+            if (!emptySlot) {
+                return null;
+            } // No space
             const stackCount = Math.min(count, def.maxStack);
             const instance = this.createItemInstance(itemId, stackCount, options);
-            if (!instance)
+            if (!instance) {
                 return null;
+            }
             emptySlot.item = instance;
             count -= stackCount;
             this.emit({
@@ -180,15 +188,17 @@ class InventoryManager {
                 timestamp: Date.now(),
             });
         }
-        return (_c = (_b = container.slots.find(s => { var _a; return ((_a = s.item) === null || _a === void 0 ? void 0 : _a.itemId) === itemId; })) === null || _b === void 0 ? void 0 : _b.item) !== null && _c !== void 0 ? _c : null;
+        return container.slots.find((s) => s.item?.itemId === itemId)?.item ?? null;
     }
     removeItem(containerId, slotIndex, count = 1) {
         const container = this.containers.get(containerId);
-        if (!container)
+        if (!container) {
             return null;
+        }
         const slot = container.slots[slotIndex];
-        if (!(slot === null || slot === void 0 ? void 0 : slot.item))
+        if (!slot?.item) {
             return null;
+        }
         const removed = { ...slot.item };
         if (slot.item.count <= count) {
             slot.item = null;
@@ -212,15 +222,18 @@ class InventoryManager {
     moveItem(fromContainerId, fromSlot, toContainerId, toSlot) {
         const fromContainer = this.containers.get(fromContainerId);
         const toContainer = this.containers.get(toContainerId);
-        if (!fromContainer || !toContainer)
+        if (!fromContainer || !toContainer) {
             return false;
+        }
         const sourceSlot = fromContainer.slots[fromSlot];
         const targetSlot = toContainer.slots[toSlot];
-        if (!(sourceSlot === null || sourceSlot === void 0 ? void 0 : sourceSlot.item) || !targetSlot)
+        if (!sourceSlot?.item || !targetSlot) {
             return false;
+        }
         const def = this.itemDefinitions.get(sourceSlot.item.itemId);
-        if (!def)
+        if (!def) {
             return false;
+        }
         // Check target container restrictions
         if (toContainer.allowedCategories && !toContainer.allowedCategories.includes(def.category)) {
             return false;
@@ -234,8 +247,9 @@ class InventoryManager {
                 const toMove = Math.min(sourceSlot.item.count, space);
                 targetSlot.item.count += toMove;
                 sourceSlot.item.count -= toMove;
-                if (sourceSlot.item.count <= 0)
+                if (sourceSlot.item.count <= 0) {
                     sourceSlot.item = null;
+                }
             }
             else {
                 // Swap
@@ -261,17 +275,24 @@ class InventoryManager {
     }
     splitStack(containerId, slotIndex, splitCount) {
         const container = this.containers.get(containerId);
-        if (!container)
+        if (!container) {
             return false;
+        }
         const slot = container.slots[slotIndex];
-        if (!(slot === null || slot === void 0 ? void 0 : slot.item) || slot.item.count <= splitCount)
+        if (!slot?.item || slot.item.count <= splitCount) {
             return false;
-        const emptySlot = container.slots.find(s => !s.item && !s.locked);
-        if (!emptySlot)
+        }
+        const emptySlot = container.slots.find((s) => !s.item && !s.locked);
+        if (!emptySlot) {
             return false;
-        const newInstance = this.createItemInstance(slot.item.itemId, splitCount, { ...slot.item, instanceId: undefined });
-        if (!newInstance)
+        }
+        const newInstance = this.createItemInstance(slot.item.itemId, splitCount, {
+            ...slot.item,
+            instanceId: undefined,
+        });
+        if (!newInstance) {
             return false;
+        }
         slot.item.count -= splitCount;
         emptySlot.item = newInstance;
         this.emit({
@@ -289,23 +310,26 @@ class InventoryManager {
     /* ── Weight & Capacity ──────────────────────────────────────── */
     getContainerWeight(containerId) {
         const container = this.containers.get(containerId);
-        if (!container)
+        if (!container) {
             return 0;
+        }
         let weight = 0;
         for (const slot of container.slots) {
             if (slot.item) {
                 const def = this.itemDefinitions.get(slot.item.itemId);
-                if (def)
+                if (def) {
                     weight += def.weight * slot.item.count;
+                }
             }
         }
         return weight;
     }
     getContainerFreeSlots(containerId) {
         const container = this.containers.get(containerId);
-        if (!container)
+        if (!container) {
             return 0;
-        return container.slots.filter(s => !s.item && !s.locked).length;
+        }
+        return container.slots.filter((s) => !s.item && !s.locked).length;
     }
     /* ── Equipment System ───────────────────────────────────────── */
     initializeEquipment(ownerId) {
@@ -316,10 +340,23 @@ class InventoryManager {
         };
         // Initialize all slots as empty
         const allSlots = [
-            'head', 'chest', 'legs', 'feet', 'hands', 'shoulders', 'back', 'waist',
-            'mainHand', 'offHand', 'ring1', 'ring2', 'neck', 'trinket1', 'trinket2',
+            'head',
+            'chest',
+            'legs',
+            'feet',
+            'hands',
+            'shoulders',
+            'back',
+            'waist',
+            'mainHand',
+            'offHand',
+            'ring1',
+            'ring2',
+            'neck',
+            'trinket1',
+            'trinket2',
         ];
-        allSlots.forEach(slot => state.slots.set(slot, null));
+        allSlots.forEach((slot) => state.slots.set(slot, null));
         this.equipment.set(ownerId, state);
         return state;
     }
@@ -332,14 +369,17 @@ class InventoryManager {
             equipState = this.initializeEquipment(ownerId);
         }
         const container = this.containers.get(containerId);
-        if (!container)
+        if (!container) {
             return false;
+        }
         const invSlot = container.slots[slotIndex];
-        if (!(invSlot === null || invSlot === void 0 ? void 0 : invSlot.item))
+        if (!invSlot?.item) {
             return false;
+        }
         const def = this.itemDefinitions.get(invSlot.item.itemId);
-        if (!(def === null || def === void 0 ? void 0 : def.equipSlot))
+        if (!def?.equipSlot) {
             return false;
+        }
         // Check requirements
         // (In real implementation, would check level, class, stats)
         // Handle two-hand weapons
@@ -348,10 +388,12 @@ class InventoryManager {
             // Unequip both hands
             const mainHand = equipState.slots.get('mainHand');
             const offHand = equipState.slots.get('offHand');
-            if (mainHand)
+            if (mainHand) {
                 this.unequipToContainer(ownerId, 'mainHand', containerId);
-            if (offHand)
+            }
+            if (offHand) {
                 this.unequipToContainer(ownerId, 'offHand', containerId);
+            }
             targetSlot = 'mainHand';
         }
         // Clone the item to equip BEFORE modifying the slot
@@ -386,18 +428,22 @@ class InventoryManager {
     }
     unequipToContainer(ownerId, equipSlot, containerId) {
         const equipState = this.equipment.get(ownerId);
-        if (!equipState)
+        if (!equipState) {
             return false;
+        }
         const equippedItem = equipState.slots.get(equipSlot);
-        if (!equippedItem)
+        if (!equippedItem) {
             return false;
+        }
         const container = this.containers.get(containerId);
-        if (!container)
+        if (!container) {
             return false;
+        }
         // Find empty slot in container
-        const emptySlot = container.slots.find(s => !s.item && !s.locked);
-        if (!emptySlot)
-            return false; // Inventory full
+        const emptySlot = container.slots.find((s) => !s.item && !s.locked);
+        if (!emptySlot) {
+            return false;
+        } // Inventory full
         emptySlot.item = equippedItem;
         equipState.slots.set(equipSlot, null);
         this.recalculateEquipmentStats(ownerId);
@@ -411,30 +457,34 @@ class InventoryManager {
         return true;
     }
     recalculateEquipmentStats(ownerId) {
-        var _a, _b;
         const equipState = this.equipment.get(ownerId);
-        if (!equipState)
+        if (!equipState) {
             return;
+        }
         equipState.totalStats.clear();
         for (const [, item] of equipState.slots) {
-            if (!item)
+            if (!item) {
                 continue;
+            }
             const def = this.itemDefinitions.get(item.itemId);
-            if (!(def === null || def === void 0 ? void 0 : def.stats))
+            if (!def?.stats) {
                 continue;
+            }
             for (const mod of def.stats) {
-                const current = (_a = equipState.totalStats.get(mod.stat)) !== null && _a !== void 0 ? _a : 0;
-                equipState.totalStats.set(mod.stat, current + ((_b = mod.flat) !== null && _b !== void 0 ? _b : 0));
+                const current = equipState.totalStats.get(mod.stat) ?? 0;
+                equipState.totalStats.set(mod.stat, current + (mod.flat ?? 0));
                 // Percent modifiers would need separate handling
             }
         }
     }
     /* ── Durability & Repair ────────────────────────────────────── */
     damageDurability(instance, damage) {
-        if (!this.config.enableDurability)
+        if (!this.config.enableDurability) {
             return false;
-        if (instance.durability === undefined)
+        }
+        if (instance.durability === undefined) {
             return false;
+        }
         instance.durability = Math.max(0, instance.durability - damage);
         if (instance.durability <= 0) {
             this.emit({
@@ -448,8 +498,9 @@ class InventoryManager {
     }
     repairItem(instance, amount) {
         const def = this.itemDefinitions.get(instance.itemId);
-        if (!(def === null || def === void 0 ? void 0 : def.maxDurability) || instance.durability === undefined)
+        if (!def?.maxDurability || instance.durability === undefined) {
             return false;
+        }
         instance.durability = Math.min(def.maxDurability, amount !== undefined ? instance.durability + amount : def.maxDurability);
         this.emit({
             type: 'item:repaired',
@@ -460,19 +511,21 @@ class InventoryManager {
     }
     /* ── Consumables ────────────────────────────────────────────── */
     useItem(containerId, slotIndex, targetEntityId) {
-        var _a;
         const container = this.containers.get(containerId);
-        if (!container)
+        if (!container) {
             return false;
+        }
         const slot = container.slots[slotIndex];
-        if (!(slot === null || slot === void 0 ? void 0 : slot.item))
+        if (!slot?.item) {
             return false;
+        }
         const def = this.itemDefinitions.get(slot.item.itemId);
-        if (!def)
+        if (!def) {
             return false;
+        }
         // Check cooldown
         if (def.cooldown) {
-            const lastUsed = (_a = this.cooldowns.get(slot.item.instanceId)) !== null && _a !== void 0 ? _a : 0;
+            const lastUsed = this.cooldowns.get(slot.item.instanceId) ?? 0;
             if (Date.now() - lastUsed < def.cooldown) {
                 return false; // On cooldown
             }
@@ -505,8 +558,9 @@ class InventoryManager {
     }
     learnRecipe(entityId, recipeId) {
         const recipe = this.recipes.get(recipeId);
-        if (!recipe || !recipe.requiresLearning)
+        if (!recipe || !recipe.requiresLearning) {
             return false;
+        }
         let learned = this.learnedRecipes.get(entityId);
         if (!learned) {
             learned = new Set();
@@ -517,28 +571,33 @@ class InventoryManager {
     }
     canCraft(entityId, recipeId, containerId) {
         const recipe = this.recipes.get(recipeId);
-        if (!recipe)
+        if (!recipe) {
             return false;
+        }
         // Check if recipe is learned
         if (recipe.requiresLearning) {
             const learned = this.learnedRecipes.get(entityId);
-            if (!(learned === null || learned === void 0 ? void 0 : learned.has(recipeId)))
+            if (!learned?.has(recipeId)) {
                 return false;
+            }
         }
         // Check ingredients
         const container = this.containers.get(containerId);
-        if (!container)
+        if (!container) {
             return false;
+        }
         for (const ingredient of recipe.ingredients) {
             const available = this.countItemsInContainer(containerId, ingredient.itemId);
-            if (available < ingredient.count)
+            if (available < ingredient.count) {
                 return false;
+            }
         }
         return true;
     }
     craft(entityId, recipeId, containerId) {
-        if (!this.canCraft(entityId, recipeId, containerId))
+        if (!this.canCraft(entityId, recipeId, containerId)) {
             return null;
+        }
         const recipe = this.recipes.get(recipeId);
         this.containers.get(containerId);
         // Check success
@@ -571,7 +630,7 @@ class InventoryManager {
             ownerId: entityId,
             recipeId,
             containerId,
-            item: output !== null && output !== void 0 ? output : undefined,
+            item: output ?? undefined,
             timestamp: Date.now(),
         });
         return output;
@@ -581,26 +640,32 @@ class InventoryManager {
         this.lootTables.set(table.id, table);
     }
     generateLoot(tableId, modifiers = {}) {
-        var _a;
         const table = this.lootTables.get(tableId);
-        if (!table)
+        if (!table) {
             return [];
+        }
         const loot = [];
         // Guaranteed drops
         if (table.guaranteedDrops) {
             for (const drop of table.guaranteedDrops) {
                 const instance = this.createItemInstance(drop.itemId, drop.count);
-                if (instance)
+                if (instance) {
                     loot.push(instance);
+                }
             }
         }
         // Roll on table
-        const validEntries = table.entries.filter(e => {
-            var _a, _b;
-            if (((_a = e.conditions) === null || _a === void 0 ? void 0 : _a.minLevel) && modifiers.levelContext && modifiers.levelContext < e.conditions.minLevel)
+        const validEntries = table.entries.filter((e) => {
+            if (e.conditions?.minLevel &&
+                modifiers.levelContext &&
+                modifiers.levelContext < e.conditions.minLevel) {
                 return false;
-            if (((_b = e.conditions) === null || _b === void 0 ? void 0 : _b.maxLevel) && modifiers.levelContext && modifiers.levelContext > e.conditions.maxLevel)
+            }
+            if (e.conditions?.maxLevel &&
+                modifiers.levelContext &&
+                modifiers.levelContext > e.conditions.maxLevel) {
                 return false;
+            }
             return true;
         });
         const totalWeight = validEntries.reduce((sum, e) => sum + e.weight, 0);
@@ -610,12 +675,13 @@ class InventoryManager {
                 random -= entry.weight;
                 if (random <= 0) {
                     // Apply drop chance with luck modifier
-                    const effectiveChance = Math.min(1, entry.dropChance + ((_a = modifiers.luckBonus) !== null && _a !== void 0 ? _a : 0));
+                    const effectiveChance = Math.min(1, entry.dropChance + (modifiers.luckBonus ?? 0));
                     if (Math.random() <= effectiveChance) {
                         const count = Math.floor(entry.minCount + Math.random() * (entry.maxCount - entry.minCount + 1));
                         const instance = this.createItemInstance(entry.itemId, count);
-                        if (instance)
+                        if (instance) {
                             loot.push(instance);
+                        }
                     }
                     break;
                 }
@@ -636,27 +702,31 @@ class InventoryManager {
         return this.shops.get(shopId);
     }
     buyFromShop(shopId, listingIndex, quantity, buyerContainerId) {
-        var _a, _b, _c;
         const shop = this.shops.get(shopId);
         const container = this.containers.get(buyerContainerId);
-        if (!shop || !container)
+        if (!shop || !container) {
             return false;
+        }
         const listing = shop.listings[listingIndex];
-        if (!listing)
+        if (!listing) {
             return false;
+        }
         // Check stock
-        if (listing.stock !== -1 && listing.stock < quantity)
+        if (listing.stock !== -1 && listing.stock < quantity) {
             return false;
+        }
         // Calculate price
         const def = this.itemDefinitions.get(listing.itemId);
-        if (!def)
+        if (!def) {
             return false;
-        const unitPrice = (_a = listing.price) !== null && _a !== void 0 ? _a : Math.ceil(def.value * shop.sellRate);
+        }
+        const unitPrice = listing.price ?? Math.ceil(def.value * shop.sellRate);
         const totalPrice = unitPrice * quantity;
         // Check buyer currency
-        const buyerCurrency = (_c = (_b = container.currency) === null || _b === void 0 ? void 0 : _b.get(listing.currencyId)) !== null && _c !== void 0 ? _c : 0;
-        if (buyerCurrency < totalPrice)
+        const buyerCurrency = container.currency?.get(listing.currencyId) ?? 0;
+        if (buyerCurrency < totalPrice) {
             return false;
+        }
         // Execute transaction
         container.currency.set(listing.currencyId, buyerCurrency - totalPrice);
         const purchased = this.addItem(buyerContainerId, listing.itemId, quantity);
@@ -683,28 +753,31 @@ class InventoryManager {
         return true;
     }
     sellToShop(shopId, sellerContainerId, slotIndex, quantity) {
-        var _a, _b;
         const shop = this.shops.get(shopId);
         const container = this.containers.get(sellerContainerId);
-        if (!shop || !container)
+        if (!shop || !container) {
             return false;
+        }
         const slot = container.slots[slotIndex];
-        if (!(slot === null || slot === void 0 ? void 0 : slot.item) || slot.item.count < quantity)
+        if (!slot?.item || slot.item.count < quantity) {
             return false;
+        }
         const def = this.itemDefinitions.get(slot.item.itemId);
-        if (!def || !def.sellable)
+        if (!def || !def.sellable) {
             return false;
+        }
         // Calculate sell price
         const unitPrice = Math.floor(def.value * shop.buyRate);
         const totalPrice = unitPrice * quantity;
         // Use first accepted currency
         const currencyId = shop.acceptedCurrencies[0];
-        if (!currencyId)
+        if (!currencyId) {
             return false;
+        }
         // Remove items
         this.removeItem(sellerContainerId, slotIndex, quantity);
         // Add currency
-        const currentCurrency = (_b = (_a = container.currency) === null || _a === void 0 ? void 0 : _a.get(currencyId)) !== null && _b !== void 0 ? _b : 0;
+        const currentCurrency = container.currency?.get(currencyId) ?? 0;
         container.currency.set(currencyId, currentCurrency + totalPrice);
         this.emit({
             type: 'shop:sold',
@@ -721,13 +794,14 @@ class InventoryManager {
     }
     /* ── Currency ───────────────────────────────────────────────── */
     addCurrency(containerId, currencyId, amount) {
-        var _a;
         const container = this.containers.get(containerId);
-        if (!container)
+        if (!container) {
             return false;
-        if (!container.currency)
+        }
+        if (!container.currency) {
             container.currency = new Map();
-        const current = (_a = container.currency.get(currencyId)) !== null && _a !== void 0 ? _a : 0;
+        }
+        const current = container.currency.get(currencyId) ?? 0;
         container.currency.set(currencyId, current + amount);
         this.emit({
             type: 'currency:changed',
@@ -740,13 +814,14 @@ class InventoryManager {
         return true;
     }
     removeCurrency(containerId, currencyId, amount) {
-        var _a;
         const container = this.containers.get(containerId);
-        if (!(container === null || container === void 0 ? void 0 : container.currency))
+        if (!container?.currency) {
             return false;
-        const current = (_a = container.currency.get(currencyId)) !== null && _a !== void 0 ? _a : 0;
-        if (current < amount)
+        }
+        const current = container.currency.get(currencyId) ?? 0;
+        if (current < amount) {
             return false;
+        }
         container.currency.set(currencyId, current - amount);
         this.emit({
             type: 'currency:changed',
@@ -759,27 +834,36 @@ class InventoryManager {
         return true;
     }
     getCurrency(containerId, currencyId) {
-        var _a, _b, _c;
-        return (_c = (_b = (_a = this.containers.get(containerId)) === null || _a === void 0 ? void 0 : _a.currency) === null || _b === void 0 ? void 0 : _b.get(currencyId)) !== null && _c !== void 0 ? _c : 0;
+        return this.containers.get(containerId)?.currency?.get(currencyId) ?? 0;
     }
     /* ── Sorting ────────────────────────────────────────────────── */
     sortContainer(containerId, criteria = 'category') {
         const container = this.containers.get(containerId);
-        if (!container)
+        if (!container) {
             return;
+        }
         const items = container.slots
-            .filter(s => s.item && !s.locked)
-            .map(s => s.item)
+            .filter((s) => s.item && !s.locked)
+            .map((s) => s.item)
             .sort((a, b) => {
             const defA = this.itemDefinitions.get(a.itemId);
             const defB = this.itemDefinitions.get(b.itemId);
-            if (!defA || !defB)
+            if (!defA || !defB) {
                 return 0;
+            }
             switch (criteria) {
                 case 'category':
                     return defA.category.localeCompare(defB.category) || defA.name.localeCompare(defB.name);
                 case 'rarity': {
-                    const rarityOrder = ['common', 'uncommon', 'rare', 'epic', 'legendary', 'mythic', 'unique'];
+                    const rarityOrder = [
+                        'common',
+                        'uncommon',
+                        'rare',
+                        'epic',
+                        'legendary',
+                        'mythic',
+                        'unique',
+                    ];
                     return rarityOrder.indexOf(defB.rarity) - rarityOrder.indexOf(defA.rarity);
                 }
                 case 'name':
@@ -791,9 +875,10 @@ class InventoryManager {
             }
         });
         // Clear unlocked slots
-        container.slots.forEach(s => {
-            if (!s.locked)
+        container.slots.forEach((s) => {
+            if (!s.locked) {
                 s.item = null;
+            }
         });
         // Fill with sorted items
         let itemIndex = 0;
@@ -813,40 +898,45 @@ class InventoryManager {
     /* ── Utility Methods ────────────────────────────────────────── */
     countItemsInContainer(containerId, itemId) {
         const container = this.containers.get(containerId);
-        if (!container)
+        if (!container) {
             return 0;
+        }
         return container.slots.reduce((sum, slot) => {
-            var _a;
-            if (((_a = slot.item) === null || _a === void 0 ? void 0 : _a.itemId) === itemId)
+            if (slot.item?.itemId === itemId) {
                 return sum + slot.item.count;
+            }
             return sum;
         }, 0);
     }
     removeItemsByIdFromContainer(containerId, itemId, count) {
         const container = this.containers.get(containerId);
-        if (!container)
+        if (!container) {
             return 0;
+        }
         let removed = 0;
         for (const slot of container.slots) {
-            if (!slot.item || slot.item.itemId !== itemId)
+            if (!slot.item || slot.item.itemId !== itemId) {
                 continue;
+            }
             const toRemove = Math.min(count - removed, slot.item.count);
             slot.item.count -= toRemove;
             removed += toRemove;
-            if (slot.item.count <= 0)
+            if (slot.item.count <= 0) {
                 slot.item = null;
-            if (removed >= count)
+            }
+            if (removed >= count) {
                 break;
+            }
         }
         return removed;
     }
     findItem(containerId, itemId) {
-        var _a;
         const container = this.containers.get(containerId);
-        if (!container)
+        if (!container) {
             return null;
+        }
         for (const slot of container.slots) {
-            if (((_a = slot.item) === null || _a === void 0 ? void 0 : _a.itemId) === itemId) {
+            if (slot.item?.itemId === itemId) {
                 return { slot, instance: slot.item };
             }
         }
@@ -901,8 +991,9 @@ const InventoryProvider = ({ manager, children }) => {
 };
 function useInventoryManager() {
     const ctx = React.useContext(InventoryContext);
-    if (!ctx)
+    if (!ctx) {
         throw new Error('useInventoryManager must be used within InventoryProvider');
+    }
     return ctx;
 }
 function useContainer(containerId) {