@jeremyckahn/farmhand 1.19.19 → 1.19.21

package/src/{enums.js → enums.ts}

@@ -7,7 +7,7 @@
  * @property farmhand.module:enums.cropType
  * @enum {string}
  */
-export const cropType = /** @type {const} */ ({
+export const cropType = /** @type {const} */ {
   ASPARAGUS: 'ASPARAGUS',
   CARROT: 'CARROT',
   CORN: 'CORN',
@@ -28,25 +28,25 @@ export const cropType = /** @type {const} */ ({
   WATERMELON: 'WATERMELON',
   WHEAT: 'WHEAT',
   WEED: 'WEED',
-})
+}
 
 /**
  * @property farmhand.module:enums.recipeType
  * @enum {string}
  */
-export const recipeType = /** @type {const} */ ({
+export const recipeType = /** @type {const} */ {
   FERMENTATION: 'FERMENTATION',
   FORGE: 'FORGE',
   KITCHEN: 'KITCHEN',
   RECYCLING: 'RECYCLING',
   WINE: 'WINE',
-})
+}
 
 /**
  * @property farmhand.module:enums.fieldMode
  * @enum {string}
  */
-export const fieldMode = /** @type {const} */ ({
+export const fieldMode = /** @type {const} */ {
   CLEANUP: 'CLEANUP',
   FERTILIZE: 'FERTILIZE',
   HARVEST: 'HARVEST',
@@ -56,13 +56,13 @@ export const fieldMode = /** @type {const} */ ({
   SET_SPRINKLER: 'SET_SPRINKLER',
   SET_SCARECROW: 'SET_SCARECROW',
   WATER: 'WATER',
-})
+}
 
 /**
  * @property farmhand.module:enums.stageFocusType
  * @enum {string}
  */
-export const stageFocusType = /** @type {const} */ ({
+export const stageFocusType = /** @type {const} */ {
   NONE: 'NONE', // Used for testing
   HOME: 'HOME',
   FIELD: 'FIELD',
@@ -72,23 +72,23 @@ export const stageFocusType = /** @type {const} */ ({
   INVENTORY: 'INVENTORY',
   WORKSHOP: 'WORKSHOP',
   CELLAR: 'CELLAR',
-})
+}
 
 /**
  * @property farmhand.module:enums.cropLifeStage
  * @enum {string}
  */
-export const cropLifeStage = /** @type {const} */ ({
+export const cropLifeStage = /** @type {const} */ {
   SEED: 'SEED',
   GROWING: 'GROWING',
   GROWN: 'GROWN',
-})
+}
 
 /**
  * @property farmhand.module:enums.itemType
  * @enum {string}
  */
-export const itemType = /** @type {const} */ ({
+export const itemType = /** @type {const} */ {
   COW_FEED: 'COW_FEED',
   CRAFTED_ITEM: 'CRAFTED_ITEM',
   CROP: 'CROP',
@@ -102,32 +102,32 @@ export const itemType = /** @type {const} */ ({
   STONE: 'STONE',
   TOOL_UPGRADE: 'TOOL_UPGRADE',
   WEED: 'WEED',
-})
+}
 
 /**
  * @property farmhand.module:enums.fertilizerType
  * @enum {string}
  */
-export const fertilizerType = /** @type {const} */ ({
+export const fertilizerType = /** @type {const} */ {
   NONE: 'NONE',
   STANDARD: 'STANDARD',
   RAINBOW: 'RAINBOW',
-})
+}
 
 /**
  * @property farmhand.module:enums.genders
  * @enum {string}
  */
-export const genders = /** @type {const} */ ({
+export const genders = /** @type {const} */ {
   FEMALE: 'FEMALE',
   MALE: 'MALE',
-})
+}
 
 /**
  * @property farmhand.module:enums.cowColors
  * @enum {string}
  */
-export const cowColors = /** @type {const} */ ({
+export const cowColors = /** @type {const} */ {
   BLUE: 'BLUE',
   BROWN: 'BROWN',
   GREEN: 'GREEN',
@@ -136,7 +136,7 @@ export const cowColors = /** @type {const} */ ({
   RAINBOW: 'RAINBOW',
   WHITE: 'WHITE',
   YELLOW: 'YELLOW',
-})
+}
 
 const { RAINBOW, ...standardCowColors } = cowColors
 export { standardCowColors }
@@ -145,7 +145,7 @@ export { standardCowColors }
  * @property farmhand.module:enums.dialogView
  * @enum {string}
  */
-export const dialogView = /** @type {const} */ ({
+export const dialogView = /** @type {const} */ {
   NONE: 'NONE',
   ACCOUNTING: 'ACCOUNTING',
   ACHIEVEMENTS: 'ACHIEVEMENTS',
@@ -155,50 +155,50 @@ export const dialogView = /** @type {const} */ ({
   PRICE_EVENTS: 'PRICE_EVENTS',
   SETTINGS: 'SETTINGS',
   STATS: 'STATS',
-})
+}
 
 /**
  * @property farmhand.module:enums.toolType
  * @enum {string}
  */
-export const toolType = /** @type {const} */ ({
+export const toolType = /** @type {const} */ {
   SCYTHE: 'SCYTHE',
   SHOVEL: 'SHOVEL',
   HOE: 'HOE',
   WATERING_CAN: 'WATERING_CAN',
-})
+}
 
 /**
  * @property farmhand.module:enums.toolLevel
  * @enum {string}
  */
-export const toolLevel = /** @type {const} */ ({
+export const toolLevel = /** @type {const} */ {
   UNAVAILABLE: 'UNAVAILABLE',
   DEFAULT: 'DEFAULT',
   BRONZE: 'BRONZE',
   IRON: 'IRON',
   SILVER: 'SILVER',
   GOLD: 'GOLD',
-})
+}
 
 /**
  * @property farmhand.module:enums.notificationSeverity
  * @enum {string}
  */
-export const notificationSeverity = /** @type {const} */ ({
+export const notificationSeverity = /** @type {const} */ {
   INFO: 'INFO',
   SUCCESS: 'SUCCESS',
   WARNING: 'WARNING',
   ERROR: 'ERROR',
-})
+}
 
 /**
  * @property farmhand.module:enums.cowTradeRejectionReason
  * @enum {string}
  */
-export const cowTradeRejectionReason = /** @type {const} */ ({
+export const cowTradeRejectionReason = /** @type {const} */ {
   REQUESTED_COW_UNAVAILABLE: 'REQUESTED_COW_UNAVAILABLE',
-})
+}
 
 /**
  * @property farmhand.module:enums.cropFamily

package/src/factories/{CoalFactory.js → CoalFactory.ts}

@@ -17,9 +17,11 @@ export default class CoalFactory extends Factory {
     const amount = chooseRandom([1, 1, 1, 2, 3])
 
     for (let i = 0; i < amount; i++) {
+      // @ts-expect-error
       spawns.push(this.spawnCoal())
     }
 
+    // @ts-expect-error
     spawns.push(this.spawnStone())
 
     return spawns

package/src/factories/{OreFactory.js → OreFactory.ts}

@@ -12,8 +12,10 @@ export default class OreFactory extends Factory {
   constructor() {
     super()
 
+    // @ts-expect-error
     this.oreOptions = []
     for (let o of SPAWNABLE_ORES) {
+      // @ts-expect-error
       this.oreOptions.push({
         ore: o,
         weight: o.spawnChance || 0,
@@ -35,6 +37,7 @@ export default class OreFactory extends Factory {
    * @private
    **/
   spawn() {
+    // @ts-expect-error
     const spawnedOption = randomChoice(this.oreOptions)
     return spawnedOption.ore
   }

package/src/factories/{ResourceFactory.test.js → ResourceFactory.test.ts}

@@ -28,6 +28,7 @@ describe('ResourceFactory', () => {
         false
       )
 
+      // @ts-expect-error
       expect(ResourceFactory.instance().generateResources(shovelLevel)).toEqual(
         []
       )
@@ -39,6 +40,7 @@ describe('ResourceFactory', () => {
       )
       vi.mocked(randomChoice).mockReturnValueOnce({ itemType: itemType.ORE })
 
+      // @ts-expect-error
       ResourceFactory.instance().generateResources(shovelLevel)
       const factory = ResourceFactory.getFactoryForItemType(itemType.ORE)
 
@@ -52,6 +54,7 @@ describe('ResourceFactory', () => {
       )
       vi.mocked(randomChoice).mockReturnValueOnce({ itemType: itemType.FUEL })
 
+      // @ts-expect-error
       ResourceFactory.instance().generateResources(shovelLevel)
       const factory = ResourceFactory.getFactoryForItemType(itemType.FUEL)
 
@@ -65,6 +68,7 @@ describe('ResourceFactory', () => {
       )
       vi.mocked(randomChoice).mockReturnValueOnce({ itemType: itemType.STONE })
 
+      // @ts-expect-error
       ResourceFactory.instance().generateResources(shovelLevel)
       const factory = ResourceFactory.getFactoryForItemType(itemType.STONE)
 

package/src/factories/{ResourceFactory.js → ResourceFactory.ts}

@@ -32,6 +32,7 @@ let instance = null
  */
 export default class ResourceFactory {
   constructor() {
+    // @ts-expect-error
     this.resourceOptions = [
       { weight: ORE_SPAWN_CHANCE, itemType: itemType.ORE },
       { weight: COAL_SPAWN_CHANCE, itemType: itemType.FUEL },
@@ -46,6 +47,7 @@ export default class ResourceFactory {
    */
   static instance() {
     if (!instance) {
+      // @ts-expect-error
       instance = new ResourceFactory()
     }
 
@@ -117,11 +119,13 @@ export default class ResourceFactory {
     }
 
     if (randomNumberService.isRandomNumberLessThan(spawnChance)) {
+      // @ts-expect-error
       const opt = randomChoice(this.resourceOptions)
       const factory = ResourceFactory.getFactoryForItemType(opt.itemType)
 
       if (factory) {
         const generated = factory.generate()
+        // @ts-expect-error
         resources = Array.isArray(generated) ? generated : [generated]
       }
     }

package/src/factories/{StoneFactory.js → StoneFactory.ts}

@@ -27,6 +27,7 @@ export default class StoneFactory extends Factory {
 
     for (const { resource, spawnChance } of spawnableResources) {
       if (randomNumberService.isRandomNumberLessThan(spawnChance)) {
+        // @ts-expect-error
         resources.push(resource)
       }
     }

package/src/{fetch-utils.js → fetch-utils.ts}

@@ -19,6 +19,7 @@ export async function getData(url = '', data = {}) {
   )
 
   // Default options are marked with *
+  // @ts-expect-error
   const response = await fetch(`${url}?${params}`, {
     ...commonFetchConfig,
     method: 'GET',
@@ -29,6 +30,7 @@ export async function getData(url = '', data = {}) {
 
 export async function postData(url = '', data = {}) {
   // Default options are marked with *
+  // @ts-expect-error
   const response = await fetch(url, {
     ...commonFetchConfig,
     method: 'POST',

package/src/game-logic/{field-purchase.test.js → field-purchase.test.ts}

@@ -30,7 +30,8 @@ describe('field expansion purchasing', () => {
 
     // Open the list of field options
     await userEvent.click(
-      within(/** @type {HTMLElement} */ (expandFieldContainer)).getByRole(
+      // @ts-expect-error
+      within(/** @type {HTMLElement} */ expandFieldContainer).getByRole(
         'combobox'
       )
     )
@@ -41,7 +42,8 @@ describe('field expansion purchasing', () => {
 
     // Make the purchase
     await userEvent.click(
-      within(/** @type {HTMLElement} */ (expandFieldContainer)).getByRole(
+      // @ts-expect-error
+      within(/** @type {HTMLElement} */ expandFieldContainer).getByRole(
         'button'
       )
     )

package/src/game-logic/reducers/{applyCrows.js → applyCrows.ts}

@@ -46,6 +46,7 @@ export const applyCrows = state => {
 
   forEachPlot(state, (_plotContents, x, y) => {
     if (doesPlotContainCrop(state.field[y][x])) {
+      // @ts-expect-error
       plotsWithCrops.push({ x, y })
     }
   })
@@ -60,11 +61,13 @@ export const applyCrows = state => {
     const attackPlotId = Math.floor(random() * plotsWithCrops.length)
     const target = plotsWithCrops.splice(attackPlotId, 1)[0]
 
+    // @ts-expect-error
     state = modifyFieldPlotAt(state, target.x, target.y, () => null)
     numCropsDestroyed += 1
   }
 
   if (numCropsDestroyed > 0) {
+    // @ts-expect-error
     notificationMessages.push(CROWS_DESTROYED('', numCropsDestroyed))
   }
 

package/src/game-logic/reducers/{applyLoanInterest.js → applyLoanInterest.ts}

@@ -17,7 +17,7 @@ export const applyLoanInterest = state => {
       ? [
           ...state.newDayNotifications,
           {
-            severity: /** @type {farmhand.notificationSeverity} */ ('warning'),
+            severity: /** @type {farmhand.notificationSeverity} */ 'warning',
             message: LOAN_BALANCE_NOTIFICATION('', newLoanBalance),
           },
         ]

package/src/game-logic/reducers/{applyPrecipitation.js → applyPrecipitation.ts}

@@ -26,10 +26,10 @@ export const applyPrecipitation = state => {
 
   if (shouldStormToday()) {
     if (fieldHasScarecrow(field)) {
-      notification = /** @type {farmhand.notification} */ ({
+      notification = /** @type {farmhand.notification} */ {
         message: STORM_DESTROYS_SCARECROWS_MESSAGE,
         severity: 'error',
-      })
+      }
 
       let { scarecrow: scarecrowsInInventory = 0 } = getInventoryQuantityMap(
         state.inventory
@@ -54,16 +54,16 @@ export const applyPrecipitation = state => {
         return null
       })
     } else {
-      notification = /** @type {farmhand.notification} */ ({
+      notification = /** @type {farmhand.notification} */ {
         message: STORM_MESSAGE,
         severity: 'info',
-      })
+      }
     }
   } else {
-    notification = /** @type {farmhand.notification} */ ({
+    notification = /** @type {farmhand.notification} */ {
       message: RAIN_MESSAGE,
       severity: 'info',
-    })
+    }
   }
 
   state = decrementItemFromInventory(

package/src/game-logic/reducers/{changeCowAutomaticHugState.js → changeCowAutomaticHugState.ts}

@@ -22,8 +22,8 @@ export const changeCowAutomaticHugState = (state, cow, doUseHuggingMachine) => {
     }
   }
 
-  state = modifyCow(state, cow.id, cow => ({
-    ...cow,
+  state = modifyCow(state, cow.id, updatedCow => ({
+    ...updatedCow,
     isUsingHuggingMachine: doUseHuggingMachine,
   }))
 

package/src/game-logic/reducers/{computeStateForNextDay.js → computeStateForNextDay.ts}

@@ -63,12 +63,12 @@ export const computeStateForNextDay = (state, isFirstDay = false) => {
 
   state = reducers.concat([adjustItemValues]).reduce(
     (acc, fn) => fn({ ...acc }),
-    /** @type {farmhand.state} */ ({
+    /** @type {farmhand.state} */ {
       ...state,
       cowForSale: generateCow(),
       dayCount: state.dayCount + 1,
       todaysNotifications: [],
-    })
+    }
   )
 
   if (state.dayCount % 365 === 0) {

package/src/game-logic/reducers/{consumeIngredients.js → consumeIngredients.ts}

@@ -28,9 +28,9 @@ export const consumeIngredients = (
   state = addExperience(state, experiencePoints)
 
   return Object.keys(recipe.ingredients || {}).reduce(
-    (state, ingredientId) =>
+    (reducerState, ingredientId) =>
       decrementItemFromInventory(
-        state,
+        reducerState,
         ingredientId,
         recipe.ingredients[ingredientId] * recipeYield
       ),

package/src/game-logic/reducers/{harvestPlot.js → harvestPlot.ts}

@@ -87,13 +87,13 @@ function harvestCrops(state, x, y) {
 
     if (seedsForHarvestedCropAreAvailable) {
       state = plantInPlot(state, x, y, seedItemIdForCrop)
-      state = modifyFieldPlotAt(state, x, y, crop => {
-        if (!crop) {
-          return crop
+      state = modifyFieldPlotAt(state, x, y, updatedCrop => {
+        if (!updatedCrop) {
+          return updatedCrop
         }
 
         return {
-          ...crop,
+          ...updatedCrop,
           fertilizerType: fertilizerType.RAINBOW,
         }
       })

package/src/game-logic/reducers/{makeFermentationRecipe.js → makeFermentationRecipe.ts}

@@ -49,6 +49,7 @@ export const makeFermentationRecipe = (
 
   state = decrementItemFromInventory(
     state,
+    // @ts-expect-error
     itemsMap.salt.id,
     howMany * saltRequirements
   )

package/src/game-logic/reducers/{makeRecipe.test.js → makeRecipe.test.ts}

@@ -55,14 +55,17 @@ describe('makeRecipe', () => {
       [recipeType.FORGE, EXPERIENCE_VALUES.FORGE_RECIPE_MADE],
       [recipeType.KITCHEN, EXPERIENCE_VALUES.KITCHEN_RECIPE_MADE],
       [recipeType.RECYCLING, EXPERIENCE_VALUES.RECYCLING_RECIPE_MADE],
-    ])('adds experience for a %s recipe', (recipeType, experienceValue) => {
-      const { experience } = makeRecipe(state, {
-        ...carrotSoup,
-        ingredients: {},
-        recipeType,
-      })
+    ])(
+      'adds experience for a %s recipe',
+      (recipeTypeLabel, experienceValue) => {
+        const { experience } = makeRecipe(state, {
+          ...carrotSoup,
+          ingredients: {},
+          recipeType: recipeTypeLabel,
+        })
 
-      expect(experience).toEqual(experienceValue)
-    })
+        expect(experience).toEqual(experienceValue)
+      }
+    )
   })
 })

package/src/game-logic/reducers/{makeWine.test.js → makeWine.test.ts}

@@ -13,7 +13,6 @@ import { makeWine } from './makeWine.js'
 const stubKegUuid = 'abc123'
 
 beforeEach(() => {
-  // @ts-expect-error
   vitest.spyOn(cellarService, '_uuid').mockReturnValue(stubKegUuid)
 })
 
@@ -169,7 +168,6 @@ describe('makeWine', () => {
   ])(
     'makes $expected.cellarInventory.length wine unit(s) based on $state.inventory.0.id: $state.inventory.0.quantity, $state.inventory.1.id: $state.inventory.1.quantity',
     ({ state, grape, howMany, expected }) => {
-      // @ts-expect-error
       const result = makeWine(state, grape, howMany)
 
       expect(result).toEqual(expected)

package/src/game-logic/reducers/{makeWine.js → makeWine.ts}

@@ -49,6 +49,7 @@ export const makeWine = (state, grape, howMany = 1) => {
 
   state = decrementItemFromInventory(
     state,
+    // @ts-expect-error
     itemsMap.yeast.id,
     wineYield * yeastRequirements
   )

package/src/game-logic/reducers/{minePlot.js → minePlot.ts}

@@ -30,6 +30,7 @@ export const minePlot = (state, x, y) => {
   }
 
   const shovelLevel = state.toolLevels[toolType.SHOVEL]
+  // @ts-expect-error
   const spawnedResources = ResourceFactory.instance().generateResources(
     shovelLevel
   )

package/src/game-logic/reducers/{processCellarSpoilage.test.js → processCellarSpoilage.test.ts}

@@ -15,7 +15,6 @@ describe('processCellarSpoilage', () => {
     const cellarInventory = [keg]
     const newDayNotifications = []
 
-    // @ts-expect-error
     const expectedState = processCellarSpoilage({
       cellarInventory,
       newDayNotifications,
@@ -33,7 +32,6 @@ describe('processCellarSpoilage', () => {
     const cellarInventory = [keg]
     const newDayNotifications = []
 
-    // @ts-expect-error
     const expectedState = processCellarSpoilage({
       cellarInventory,
       newDayNotifications,
@@ -51,7 +49,6 @@ describe('processCellarSpoilage', () => {
     const cellarInventory = [keg]
     const newDayNotifications = []
 
-    // @ts-expect-error
     const expectedState = processCellarSpoilage({
       cellarInventory,
       newDayNotifications,
@@ -69,7 +66,6 @@ describe('processCellarSpoilage', () => {
     const cellarInventory = [keg]
     const newDayNotifications = []
 
-    // @ts-expect-error
     const expectedState = processCellarSpoilage({
       cellarInventory,
       newDayNotifications,
@@ -77,7 +73,6 @@ describe('processCellarSpoilage', () => {
 
     expect(expectedState.newDayNotifications).toEqual([
       {
-        // @ts-expect-error
         message: KEG_SPOILED_MESSAGE`${keg}`,
         severity: 'error',
       },

package/src/game-logic/reducers/{processCellarSpoilage.js → processCellarSpoilage.ts}

@@ -32,7 +32,6 @@ export const processCellarSpoilage = state => {
         newDayNotifications: [
           ...state.newDayNotifications,
           {
-            // @ts-expect-error
             message: KEG_SPOILED_MESSAGE`${keg}`,
             severity: 'error',
           },

package/src/game-logic/reducers/{processCowFertilizerProduction.js → processCowFertilizerProduction.ts}

@@ -44,7 +44,7 @@ export const processCowFertilizerProduction = state => {
     newDayNotifications.push({
       message: FERTILIZERS_PRODUCED(
         '',
-        /** @type {Record<string, number>} */ (fertilizersProduced)
+        /** @type {Record<string, number>} */ fertilizersProduced
       ),
       severity: 'success',
     })

package/src/game-logic/reducers/{processLevelUp.js → processLevelUp.ts}

@@ -35,7 +35,9 @@ export const processLevelUp = (state, oldLevel) => {
         getRandomLevelUpRewardQuantity(i),
         true
       )
+      // @ts-expect-error
     } else if (levelObject?.unlocksTool) {
+      // @ts-expect-error
       state = unlockTool(state, levelObject.unlocksTool)
     }
     // This handles an edge case where the player levels up to level that
@@ -43,6 +45,7 @@ export const processLevelUp = (state, oldLevel) => {
     // selected. In that case, update the hoveredPlotRangeSize state.
     else if (
       levelObject &&
+      // @ts-expect-error
       levelObject.increasesSprinklerRange &&
       selectedItemId === SPRINKLER_ITEM_ID
     ) {

package/src/game-logic/reducers/{purchaseField.test.js → purchaseField.test.ts}

@@ -50,8 +50,10 @@ describe('purchaseField', () => {
       for (let y = 0; y < fieldSize.rows; y++) {
         const row = []
         for (let x = 0; x < fieldSize.columns; x++) {
+          // @ts-expect-error
           row.push(null)
         }
+        // @ts-expect-error
         expectedField.push(row)
       }
 

package/src/game-logic/reducers/{purchaseField.js → purchaseField.ts}

@@ -25,9 +25,10 @@ export const purchaseField = (state, fieldId) => {
   return {
     ...state,
     purchasedField: fieldId,
-    field: nullArray(rows).map((_, row) =>
+    field: nullArray(rows).map((_, rowIndex) =>
       nullArray(columns).map(
-        (_, column) => (field[row] && field[row][column]) || null
+        (__, columnIdx) =>
+          (field[rowIndex] && field[rowIndex][columnIdx]) || null
       )
     ),
     money: moneyTotal(money, -price),

package/src/game-logic/reducers/{purchaseForest.test.js → purchaseForest.test.tsx}

@@ -62,7 +62,7 @@ describe('purchaseForest', () => {
 
   describe('forest expansion', () => {
     test('forest expands without destroying existing data', () => {
-      const expectedForest = /** @type {Array<Array<any>>} */ ([])
+      const expectedForest = /** @type {Array<Array<any>>} */ []
       const forestSize = PURCHASABLE_FOREST_SIZES.get(1)
 
       if (!forestSize) {
@@ -70,10 +70,12 @@ describe('purchaseForest', () => {
       }
 
       for (let y = 0; y < forestSize.rows; y++) {
-        const row = /** @type {Array<any>} */ ([])
+        const row = /** @type {Array<any>} */ []
         for (let x = 0; x < forestSize.columns; x++) {
+          // @ts-expect-error
           row.push(null)
         }
+        // @ts-expect-error
         expectedForest.push(row)
       }
 
@@ -88,7 +90,9 @@ describe('purchaseForest', () => {
         1
       )
 
+      // @ts-expect-error
       expectedForest[0][0] = testTree()
+      // @ts-expect-error
       expectedForest[1][1] = testTree()
 
       expect(forest).toEqual(expectedForest)