@shipload/sdk 1.0.0-next.45 → 1.0.0-next.46

package/src/resolution/resolve-item.ts

@@ -1,7 +1,7 @@
 import {UInt16, UInt64} from '@wharfkit/antelope'
 import type {UInt16Type, UInt64Type} from '@wharfkit/antelope'
 import type {ResourceCategory} from '../types'
-import {getItem} from '../data/catalog'
+import {getItem, getModules} from '../data/catalog'
 import {getEntityLayout} from '../data/recipes-runtime'
 import {entityMetadata, itemMetadata} from '../data/metadata'
 import {
@@ -26,26 +26,13 @@ import {
     computeGeneratorCapabilities,
     computeHaulerCapabilities,
     computeLoaderCapabilities,
+    computeBaseCapacity,
     computeBaseHullmass,
-    computeShipHullCapabilities,
-    computeWarehouseHullCapabilities,
-    computeContainerCapabilities,
-    computeContainerT2Capabilities,
     computeStorageCapabilities,
 } from '../derivation/capabilities'
 import {applySlotMultiplierUint32} from '../entities/slot-multiplier'
 import {categoryColors, componentIcon, itemAbbreviations, moduleIcon} from '../data/colors'
 import type {ServerContract} from '../contracts'
-import {
-    ITEM_CONTAINER_T1_PACKED,
-    ITEM_CONTAINER_T2_PACKED,
-    ITEM_EXTRACTOR_T1_PACKED,
-    ITEM_FACTORY_T1_PACKED,
-    ITEM_MASS_CATCHER_T1_PACKED,
-    ITEM_MASS_DRIVER_T1_PACKED,
-    ITEM_SHIP_T1_PACKED,
-    ITEM_WAREHOUSE_T1_PACKED,
-} from '../data/item-ids'
 
 export interface ResolvedItemStat {
     key: string
@@ -69,6 +56,10 @@ export interface ResolvedModuleSlot {
     capability?: string
     installed: boolean
     attributes?: {label: string; value: number}[]
+    slotLabel?: string
+    slotType?: string
+    outputPct?: number
+    maxTier?: number
 }
 
 export interface ResolvedItem {
@@ -218,7 +209,7 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_HAULER: {
-            const caps = computeHaulerCapabilities(stats)
+            const caps = computeHaulerCapabilities(stats, tier)
             return {
                 capability: 'Hauling',
                 attributes: [
@@ -257,11 +248,22 @@ function computeCapabilityGroup(
     }
 }
 
+// Recipe-less higher-tier modules reuse the T1 stat layout of their module type.
+function decodeModuleStats(id: number, big: bigint): Record<string, number> {
+    const decoded = decodeCraftedItemStats(id, big)
+    if (Object.keys(decoded).length > 0) return decoded
+    const moduleType = getItem(id).moduleType
+    if (!moduleType) return decoded
+    const t1 = getModules({moduleType, tier: 1})[0]
+    if (!t1) return decoded
+    return decodeCraftedItemStats(Number(t1.id), big)
+}
+
 function resolveModule(id: number, stats?: UInt64Type): ResolvedItem {
     const item = getItem(id)
     let attributes: ResolvedAttributeGroup[] | undefined
     if (stats !== undefined) {
-        const decoded = decodeCraftedItemStats(id, toBigStats(stats))
+        const decoded = decodeModuleStats(id, toBigStats(stats))
         const modType = getModuleCapabilityType(id)
         const group = computeCapabilityGroup(modType, decoded, item.tier)
         if (group) attributes = [group]
@@ -285,21 +287,9 @@ function hullCapsForEntity(
     hullmass: number
     capacity: number
 } {
-    switch (itemId) {
-        case ITEM_SHIP_T1_PACKED:
-            return computeShipHullCapabilities(decoded)
-        case ITEM_WAREHOUSE_T1_PACKED:
-            return computeWarehouseHullCapabilities(decoded)
-        case ITEM_EXTRACTOR_T1_PACKED:
-        case ITEM_FACTORY_T1_PACKED:
-        case ITEM_MASS_DRIVER_T1_PACKED:
-        case ITEM_MASS_CATCHER_T1_PACKED:
-        case ITEM_CONTAINER_T1_PACKED:
-            return computeContainerCapabilities(decoded)
-        case ITEM_CONTAINER_T2_PACKED:
-            return computeContainerT2Capabilities(decoded)
-        default:
-            return {hullmass: computeBaseHullmass(decoded), capacity: 0}
+    return {
+        hullmass: computeBaseHullmass(decoded),
+        capacity: computeBaseCapacity(itemId, decoded),
     }
 }
 
@@ -334,11 +324,17 @@ function resolveEntity(
     if (layout && layout.slots.length > 0) {
         const slotLabels = entityMetadata[id]?.moduleSlotLabels ?? []
         moduleSlots = layout.slots.map((slot, i) => {
+            const slotInfo = {
+                slotLabel: slotLabels[i] ?? slot.type,
+                slotType: slot.type,
+                outputPct: slot.outputPct,
+                maxTier: slot.maxTier,
+            }
             const mod = modules?.[i]
             if (mod?.installed) {
                 const modItemId = Number(mod.installed.item_id.value.toString())
                 const modStats = BigInt(mod.installed.stats.toString())
-                const decodedStats = decodeCraftedItemStats(modItemId, modStats)
+                const decodedStats = decodeModuleStats(modItemId, modStats)
                 const modType = getModuleCapabilityType(modItemId)
                 let modName = 'Module'
                 let modTier = 1
@@ -355,11 +351,13 @@ function resolveEntity(
                     capability: group?.capability,
                     installed: true,
                     attributes: group?.attributes,
+                    ...slotInfo,
                 }
             }
             return {
                 name: slotLabels[i] ?? slot.type,
                 installed: false,
+                ...slotInfo,
             }
         })
     }

package/src/scheduling/projection.ts

@@ -167,7 +167,14 @@ function recomputeCaps(entity: Projectable): ProjectedCaps | undefined {
         loaderLanes: (caps.loaderLanes ?? []).map(toLoaderLane),
         gathererLanes: (caps.gathererLanes ?? []).map(toGathererLane),
         crafterLanes: (caps.crafterLanes ?? []).map(toCrafterLane),
-        hauler: caps.hauler ? ServerContract.Types.hauler_stats.from(caps.hauler) : undefined,
+        hauler: caps.hauler
+            ? ServerContract.Types.hauler_stats.from({
+                  capacity: caps.hauler.capacity,
+                  efficiency: caps.hauler.efficiency,
+                  drain: caps.hauler.drain,
+                  capacity_by_tier: caps.hauler.capacityByTier,
+              })
+            : undefined,
         launcher: caps.launcher
             ? ServerContract.Types.launcher_stats.from({
                   charge_rate: caps.launcher.chargeRate,

package/src/subscriptions/manager.cluster.test.ts

@@ -29,10 +29,15 @@ describe('cluster delta routing', () => {
             sub_id: handle.subId,
             hub_id: 42,
             seq: 7,
-            cells: [{gx: 0, gy: 1, entity: 99}],
+            cells: [{gx: 0, gy: 1, entity: 99, type: 'warehouse'}],
         })
         expect(received).toEqual([
-            {hubId: 42, seq: 7, cells: [{gx: 0, gy: 1, entity: 99}], erased: false},
+            {
+                hubId: 42,
+                seq: 7,
+                cells: [{gx: 0, gy: 1, entity: 99, type: 'warehouse'}],
+                erased: false,
+            },
         ])
     })
 

package/src/subscriptions/types.ts

@@ -143,6 +143,7 @@ export interface ClusterCellWire {
     gx: number
     gy: number
     entity: number
+    type?: string
 }
 
 export type ClusterDeltaMessage = {

package/src/utils/cargo.test.ts

@@ -0,0 +1,14 @@
+import {describe, expect, test} from 'bun:test'
+import {cargoRef} from './cargo'
+
+describe('cargoRef', () => {
+    test('forwards entity_id when provided', () => {
+        const ref = cargoRef({item_id: 10201, stats: 196849n, modules: [], entity_id: 42n})
+        expect(ref.entity_id).toBe(42n)
+    })
+
+    test('omits entity_id when absent', () => {
+        const ref = cargoRef({item_id: 10201, stats: 196849n})
+        expect(ref.entity_id).toBeUndefined()
+    })
+})

package/src/utils/cargo.ts

@@ -4,11 +4,13 @@ export function cargoRef(src: {
     item_id: number
     stats: bigint | number
     modules?: ServerContract.Types.module_entry[]
+    entity_id?: bigint | number
 }): ServerContract.ActionParams.Type.cargo_ref {
     return {
         item_id: src.item_id,
         stats: src.stats,
         modules: src.modules ?? [],
+        entity_id: src.entity_id,
     }
 }