@shipload/sdk 1.0.0-next.74 → 1.0.0-next.75

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "1.0.0-next.74",
+    "version": "1.0.0-next.75",
     "homepage": "https://github.com/shipload/toolkit/tree/master/packages/sdk",
     "repository": {
         "type": "git",

package/src/data/component-process.test.ts

@@ -0,0 +1,119 @@
+import {describe, expect, test} from 'bun:test'
+import {
+    ITEM_BEAM,
+    ITEM_ENGINE_T1,
+    ITEM_ORE_T1,
+    ITEM_PLATE,
+    ITEM_PLATE_T2,
+    ITEM_PROSPECTOR_T1A_PACKED,
+    ITEM_PROSPECTOR_T2A_PACKED,
+    ITEM_PROSPECTOR_T2B_PACKED,
+    ITEM_ROUSTABOUT_T1A_PACKED,
+    ITEM_STORAGE_T1,
+} from './item-ids'
+import {getComponents} from './catalog'
+import {getRecipe} from './recipes-runtime'
+import {completeComponentSet, getComponentProcess} from './component-process'
+import {resolveItem} from '../resolution/resolve-item'
+
+function inputsOf(itemId: number) {
+    const recipe = getRecipe(itemId)
+    if (!recipe) throw new Error(`no recipe for ${itemId}`)
+    return recipe.inputs
+}
+
+describe('component process', () => {
+    test('every component at every tier is refined or machined, five of each per tier', () => {
+        const tiers = new Set(getComponents().map((item) => item.tier))
+        for (const tier of tiers) {
+            const kinds = getComponents({tier}).map((item) => getComponentProcess(item.id))
+            expect(kinds.filter((k) => k === 'refined').length).toBe(5)
+            expect(kinds.filter((k) => k === 'machined').length).toBe(5)
+        }
+    })
+
+    test('the refined five are the single-resource components', () => {
+        const refined = getComponents({tier: 1})
+            .filter((item) => getComponentProcess(item.id) === 'refined')
+            .map((item) => item.name)
+            .sort()
+        expect(refined).toEqual(['Ceramic', 'Plasma Cell', 'Plate', 'Polymer', 'Sensor'])
+    })
+
+    test('the kind holds across tiers', () => {
+        expect(getComponentProcess(ITEM_PLATE)).toBe('refined')
+        expect(getComponentProcess(ITEM_PLATE_T2)).toBe('refined')
+        expect(getComponentProcess(ITEM_BEAM)).toBe('machined')
+    })
+
+    test('non-components and unknown ids have no kind', () => {
+        expect(getComponentProcess(ITEM_ORE_T1)).toBeUndefined()
+        expect(getComponentProcess(ITEM_ENGINE_T1)).toBeUndefined()
+        expect(getComponentProcess(ITEM_ROUSTABOUT_T1A_PACKED)).toBeUndefined()
+        expect(getComponentProcess(65535)).toBeUndefined()
+    })
+
+    test('resolveItem carries the kind for components only', () => {
+        expect(resolveItem(ITEM_BEAM).process).toBe('machined')
+        expect(resolveItem(ITEM_PLATE_T2).process).toBe('refined')
+        expect(resolveItem(ITEM_ORE_T1).process).toBeUndefined()
+    })
+})
+
+describe('completeComponentSet', () => {
+    test('recognises the hull First and Second step recipes', () => {
+        expect(completeComponentSet(inputsOf(ITEM_ROUSTABOUT_T1A_PACKED))).toEqual({
+            process: 'refined',
+            tier: 1,
+            quantity: 200,
+        })
+        expect(completeComponentSet(inputsOf(ITEM_PROSPECTOR_T1A_PACKED))).toEqual({
+            process: 'machined',
+            tier: 1,
+            quantity: 100,
+        })
+        expect(completeComponentSet(inputsOf(ITEM_PROSPECTOR_T2A_PACKED))).toEqual({
+            process: 'refined',
+            tier: 2,
+            quantity: 200,
+        })
+        expect(completeComponentSet(inputsOf(ITEM_PROSPECTOR_T2B_PACKED))).toEqual({
+            process: 'machined',
+            tier: 2,
+            quantity: 150,
+        })
+    })
+
+    test('a mixed module recipe is not a complete set', () => {
+        expect(completeComponentSet(inputsOf(ITEM_STORAGE_T1))).toBeNull()
+    })
+
+    test('unequal quantities keep the set but drop the shared quantity', () => {
+        const inputs = inputsOf(ITEM_ROUSTABOUT_T1A_PACKED).map((input, index) =>
+            index === 0 ? {...input, quantity: 50} : input
+        )
+        expect(completeComponentSet(inputs)).toEqual({process: 'refined', tier: 1, quantity: null})
+    })
+
+    test('one machined part among four refined is not a set', () => {
+        const inputs = inputsOf(ITEM_ROUSTABOUT_T1A_PACKED).map((input, index) =>
+            index === 0 ? {...input, itemId: ITEM_BEAM} : input
+        )
+        expect(completeComponentSet(inputs)).toBeNull()
+    })
+
+    test('a repeated family is not a set', () => {
+        const inputs = inputsOf(ITEM_ROUSTABOUT_T1A_PACKED).map((input) => ({
+            ...input,
+            itemId: ITEM_PLATE,
+        }))
+        expect(completeComponentSet(inputs)).toBeNull()
+    })
+
+    test('mixed tiers are not a set', () => {
+        const inputs = inputsOf(ITEM_ROUSTABOUT_T1A_PACKED).map((input, index) =>
+            index === 0 ? {...input, itemId: ITEM_PLATE_T2} : input
+        )
+        expect(completeComponentSet(inputs)).toBeNull()
+    })
+})

package/src/data/component-process.ts

@@ -0,0 +1,33 @@
+import {getItem} from './catalog'
+import {getItemFamily, type ComponentProcess} from './metadata'
+import type {RecipeInput} from './recipes-runtime'
+
+export const COMPONENT_PROCESS_ORDER: readonly ComponentProcess[] = ['refined', 'machined']
+
+export function getComponentProcess(itemId: number): ComponentProcess | undefined {
+    return getItemFamily(itemId)?.process
+}
+
+export interface CompleteComponentSet {
+    process: ComponentProcess
+    tier: number
+    quantity: number | null
+}
+
+export function completeComponentSet(inputs: readonly RecipeInput[]): CompleteComponentSet | null {
+    const parts = inputs.filter((input) => getComponentProcess(input.itemId) !== undefined)
+    if (parts.length !== 5) return null
+    const process = getComponentProcess(parts[0].itemId)
+    const tier = getItem(parts[0].itemId).tier
+    const families = new Set<string>()
+    for (const part of parts) {
+        const item = getItem(part.itemId)
+        if (getComponentProcess(part.itemId) !== process || item.tier !== tier) return null
+        families.add(item.family)
+    }
+    if (!process || families.size !== 5) return null
+    const quantity = parts.every((part) => part.quantity === parts[0].quantity)
+        ? parts[0].quantity
+        : null
+    return {process, tier, quantity}
+}

package/src/data/metadata.ts

@@ -1,9 +1,12 @@
 import items from './items.json'
 
+export type ComponentProcess = 'refined' | 'machined'
+
 export interface ItemFamily {
     name: string
     description: string
     color: string
+    process?: ComponentProcess
 }
 
 export interface EntityMetadata {
@@ -14,27 +17,27 @@ export const itemFamilies: Record<string, ItemFamily> = {
     // === Resources ===
     ore: {
         name: 'Ore',
-        description: 'Refines into Plate and Beam.',
+        description: 'Goes into Plate and Beam.',
         color: '#C26D3F',
     },
     crystal: {
         name: 'Crystal',
-        description: 'Refines into Sensors and Resonators.',
+        description: 'Goes into Sensors and Resonators.',
         color: '#4ADBFF',
     },
     gas: {
         name: 'Gas',
-        description: 'Refines into Plasma Cells and Reactors.',
+        description: 'Goes into Plasma Cells and Reactors.',
         color: '#B877FF',
     },
     regolith: {
         name: 'Regolith',
-        description: 'Refines into Ceramic and Frame.',
+        description: 'Goes into Ceramic and Frame.',
         color: '#C4A57B',
     },
     biomass: {
         name: 'Biomass',
-        description: 'Refines into Polymer and Resin.',
+        description: 'Goes into Polymer and Resin.',
         color: '#5A8B3E',
     },
 
@@ -43,51 +46,61 @@ export const itemFamilies: Record<string, ItemFamily> = {
         name: 'Plate',
         description: 'Goes into Cargo Holds, Containers, and hulls.',
         color: '#7B8D9E',
+        process: 'refined',
     },
     frame: {
         name: 'Frame',
         description: 'Goes into Limpet Bays, Cargo Holds, and hulls.',
         color: '#C4A57B',
+        process: 'machined',
     },
     'plasma-cell': {
         name: 'Plasma Cell',
         description: 'Goes into Engines, Battery Banks, and hulls.',
         color: '#E86344',
+        process: 'refined',
     },
     resonator: {
         name: 'Resonator',
         description: 'Goes into Power Cores, Tractor Beams, Warp Drives, and hulls.',
         color: '#4ADBFF',
+        process: 'machined',
     },
     beam: {
         name: 'Beam',
         description: 'Goes into Limpet Bays and hulls.',
         color: '#7B8D9E',
+        process: 'machined',
     },
     sensor: {
         name: 'Sensor',
         description: 'Goes into Fabricators, Assembly Arms, and hulls.',
         color: '#4ADBFF',
+        process: 'refined',
     },
     polymer: {
         name: 'Polymer',
         description: 'Goes into Shuttle Bays, Battery Banks, and hulls.',
         color: '#5A8B3E',
+        process: 'refined',
     },
     ceramic: {
         name: 'Ceramic',
         description: 'Goes into Assembly Arms, Containers, and hulls.',
         color: '#C4A57B',
+        process: 'refined',
     },
     reactor: {
         name: 'Reactor',
         description: 'Goes into Fabricators, Warp Drives, and hulls.',
         color: '#B877FF',
+        process: 'machined',
     },
     resin: {
         name: 'Resin',
         description: 'Goes into Tractor Beams and hulls.',
         color: '#5A8B3E',
+        process: 'machined',
     },
 
     // === Modules ===

package/src/index-module.ts

@@ -141,7 +141,13 @@ export {
     categoryLabelFromIndex,
 } from './data/catalog'
 export {getItemFamily, itemFamilies, itemFamilyKey} from './data/metadata'
-export type {ItemFamily} from './data/metadata'
+export type {ComponentProcess, ItemFamily} from './data/metadata'
+export {
+    COMPONENT_PROCESS_ORDER,
+    completeComponentSet,
+    getComponentProcess,
+} from './data/component-process'
+export type {CompleteComponentSet} from './data/component-process'
 export {getCurrentEpoch, getEpochInfo} from './scheduling/epoch'
 export type {EpochInfo} from './scheduling/epoch'
 export {

package/src/resolution/resolve-item.ts

@@ -5,6 +5,8 @@ import {getItem, getModules} from '../data/catalog'
 import {ENTITY_SHIP, getPackedEntityType} from '../data/kind-registry'
 import {getEntityLayout} from '../data/recipes-runtime'
 import {entityMetadata, getItemFamily} from '../data/metadata'
+import type {ComponentProcess} from '../data/metadata'
+import {getComponentProcess} from '../data/component-process'
 import {
     getModuleCapabilityType,
     isModuleItem,
@@ -75,6 +77,7 @@ export interface ResolvedItem {
     tier: number
     mass: number
     itemType: ResolvedItemType
+    process?: ComponentProcess
     stats?: ResolvedItemStat[]
     attributes?: ResolvedAttributeGroup[]
     moduleSlots?: ResolvedModuleSlot[]
@@ -149,6 +152,7 @@ function resolveComponent(id: number, stats?: UInt64Type): ResolvedItem {
         tier: item.tier,
         mass: item.mass,
         itemType: 'component',
+        process: getComponentProcess(id),
         stats: resolvedStats,
     }
 }