@jeremyckahn/farmhand 1.20.0 → 1.20.2

package/src/utils/getGrowingPhase.ts

@@ -2,23 +2,14 @@ import { itemsMap } from '../data/maps.js'
 import { LARGEST_PURCHASABLE_FIELD_SIZE } from '../constants.js'
 
 import { memoize } from './memoize.js'
+import { getGrowingPhaseForTimeline } from './getGrowingPhaseForTimeline.js'
 
 export const getGrowingPhase = memoize(
   (crop: farmhand.crop) => {
     const { itemId, daysWatered = 0 } = crop
     const { cropTimeline = [] } = itemsMap[itemId]
 
-    let daysGrowing = daysWatered + 1
-    let phase = 0
-
-    for (let value of cropTimeline) {
-      if (daysGrowing - value <= 0) break
-
-      daysGrowing -= value
-      phase += 1
-    }
-
-    return phase
+    return getGrowingPhaseForTimeline(cropTimeline, daysWatered)
   },
   {
     cacheSize:

package/src/utils/getGrowingPhaseForTimeline.ts

@@ -2,7 +2,7 @@ export const getGrowingPhaseForTimeline = (
   timeline: number[],
   daysElapsed: number
 ): number => {
-  let daysGrowing = daysElapsed + 1
+  let daysGrowing = Math.floor(daysElapsed) + 1
   let phase = 0
 
   for (const value of timeline) {

package/src/utils/getKegDisplayName.test.ts

@@ -0,0 +1,17 @@
+import { carrot } from '../data/crops/index.js'
+import { wineChardonnay } from '../data/recipes.js'
+import { FERMENTED_CROP_NAME } from '../templates.js'
+
+import { getKegDisplayName } from './getKegDisplayName.js'
+
+describe('getKegDisplayName', () => {
+  test('returns the item name for a wine recipe', () => {
+    expect(getKegDisplayName(wineChardonnay)).toEqual(wineChardonnay.name)
+  })
+
+  test('returns the fermented crop name for a generic fermentable item', () => {
+    expect(getKegDisplayName(carrot as farmhand.item)).toEqual(
+      FERMENTED_CROP_NAME('', carrot as farmhand.item)
+    )
+  })
+})

package/src/utils/getKegDisplayName.ts

@@ -0,0 +1,10 @@
+import { wineService } from '../services/wine.js'
+import { FERMENTED_CROP_NAME } from '../templates.js'
+
+export const getKegDisplayName = (item: farmhand.item): string => {
+  if (wineService.isWineRecipe(item)) {
+    return item.name
+  }
+
+  return FERMENTED_CROP_NAME('', item)
+}

package/src/utils/getValidatedStageFocusFromHash.test.ts

@@ -0,0 +1,72 @@
+import { stageFocusType } from '../enums.js'
+
+import { getValidatedStageFocusFromHash } from './getValidatedStageFocusFromHash.js'
+
+const { FIELD, FOREST, HOME } = stageFocusType
+
+const defaultState = {
+  experience: 0,
+  purchasedCellar: 0,
+  purchasedCowPen: 0,
+  showHomeScreen: true,
+}
+
+describe('getValidatedStageFocusFromHash', () => {
+  test('returns undefined when the hash has no view param', () => {
+    window.history.replaceState({}, '', `${window.location.pathname}`)
+
+    expect(getValidatedStageFocusFromHash(defaultState)).toBeUndefined()
+  })
+
+  test('returns the view when it is unlocked for the given state', () => {
+    window.history.replaceState(
+      {},
+      '',
+      `${window.location.pathname}#?view=FIELD`
+    )
+
+    expect(getValidatedStageFocusFromHash(defaultState)).toEqual(FIELD)
+  })
+
+  test('returns undefined when the view is not unlocked for the given state', () => {
+    window.history.replaceState(
+      {},
+      '',
+      `${window.location.pathname}#?view=FOREST`
+    )
+
+    expect(getValidatedStageFocusFromHash(defaultState)).toBeUndefined()
+  })
+
+  test('returns the view once its unlock requirement is met', () => {
+    window.history.replaceState(
+      {},
+      '',
+      `${window.location.pathname}#?view=FOREST`
+    )
+
+    expect(
+      getValidatedStageFocusFromHash({ ...defaultState, experience: 20_000 })
+    ).toEqual(FOREST)
+  })
+
+  test('returns undefined when the hash names a view outside stageFocusType entirely', () => {
+    window.history.replaceState(
+      {},
+      '',
+      `${window.location.pathname}#?view=NOT_A_REAL_VIEW`
+    )
+
+    expect(getValidatedStageFocusFromHash(defaultState)).toBeUndefined()
+  })
+
+  test('returns HOME when showHomeScreen is true, matching the default view list', () => {
+    window.history.replaceState(
+      {},
+      '',
+      `${window.location.pathname}#?view=HOME`
+    )
+
+    expect(getValidatedStageFocusFromHash(defaultState)).toEqual(HOME)
+  })
+})

package/src/utils/getValidatedStageFocusFromHash.ts

@@ -0,0 +1,43 @@
+import { stageFocusType } from '../enums.js'
+
+import { getLevelEntitlements } from './getLevelEntitlements.js'
+import { getViewList } from './getViewList.js'
+import {
+  getHashQueryParams,
+  VIEW_QUERY_PARAM_NAME,
+} from './hashQueryParams.js'
+import { levelAchieved } from './levelAchieved.js'
+
+/**
+ * Reads the URL hash's `view` param and returns it only if it names a view
+ * that's actually unlocked for the given state - guards against a
+ * bookmarked/shared URL (or a stale browser history entry reached via
+ * back/forward) pointing at a screen the current save hasn't unlocked,
+ * since Stage.tsx renders whichever view stageFocus names with no unlock
+ * check of its own. Used both at boot and when reacting to popstate.
+ */
+export const getValidatedStageFocusFromHash = (
+  candidateState: Pick<
+    farmhand.state,
+    'experience' | 'purchasedCellar' | 'purchasedCowPen' | 'showHomeScreen'
+  >
+): farmhand.stageFocusType | undefined => {
+  const stageFocusFromUrl = getHashQueryParams().get(VIEW_QUERY_PARAM_NAME)
+
+  if (!stageFocusFromUrl) return undefined
+
+  const isForestUnlockedForState = getLevelEntitlements(
+    levelAchieved(candidateState.experience)
+  ).stageFocusType[stageFocusType.FOREST]
+
+  const availableViews = getViewList({
+    isForestUnlocked: isForestUnlockedForState,
+    purchasedCellar: candidateState.purchasedCellar,
+    purchasedCowPen: candidateState.purchasedCowPen,
+    showHomeScreen: candidateState.showHomeScreen,
+  })
+
+  return availableViews.find(
+    availableView => availableView === stageFocusFromUrl
+  )
+}

package/src/utils/getViewList.test.ts

@@ -0,0 +1,73 @@
+import { stageFocusType } from '../enums.js'
+
+import { getViewList } from './getViewList.js'
+
+const { CELLAR, COW_PEN, FIELD, HOME, SHOP, WORKSHOP, FOREST } = stageFocusType
+
+describe('getViewList', () => {
+  test('returns the standard views plus Home and Workshop by default', () => {
+    expect(
+      getViewList({
+        isForestUnlocked: false,
+        purchasedCellar: 0,
+        purchasedCowPen: 0,
+        showHomeScreen: true,
+      })
+    ).toEqual([HOME, SHOP, FIELD, WORKSHOP])
+  })
+
+  test('omits Home when showHomeScreen is false', () => {
+    expect(
+      getViewList({
+        isForestUnlocked: false,
+        purchasedCellar: 0,
+        purchasedCowPen: 0,
+        showHomeScreen: false,
+      })
+    ).toEqual([SHOP, FIELD, WORKSHOP])
+  })
+
+  test('includes Forest only when isForestUnlocked is true', () => {
+    expect(
+      getViewList({
+        isForestUnlocked: true,
+        purchasedCellar: 0,
+        purchasedCowPen: 0,
+        showHomeScreen: true,
+      })
+    ).toEqual([HOME, SHOP, FIELD, FOREST, WORKSHOP])
+  })
+
+  test('includes Cow Pen only when purchasedCowPen is truthy', () => {
+    expect(
+      getViewList({
+        isForestUnlocked: false,
+        purchasedCellar: 0,
+        purchasedCowPen: 1,
+        showHomeScreen: true,
+      })
+    ).toEqual([HOME, SHOP, FIELD, COW_PEN, WORKSHOP])
+  })
+
+  test('includes Cellar only when purchasedCellar is truthy', () => {
+    expect(
+      getViewList({
+        isForestUnlocked: false,
+        purchasedCellar: 1,
+        purchasedCowPen: 0,
+        showHomeScreen: true,
+      })
+    ).toEqual([HOME, SHOP, FIELD, WORKSHOP, CELLAR])
+  })
+
+  test('includes every optional view in the correct order when all are unlocked', () => {
+    expect(
+      getViewList({
+        isForestUnlocked: true,
+        purchasedCellar: 1,
+        purchasedCowPen: 1,
+        showHomeScreen: true,
+      })
+    ).toEqual([HOME, SHOP, FIELD, FOREST, COW_PEN, WORKSHOP, CELLAR])
+  })
+})

package/src/utils/getViewList.ts

@@ -0,0 +1,46 @@
+import { STANDARD_VIEW_LIST } from '../constants.js'
+import { stageFocusType } from '../enums.js'
+
+/**
+ * The ordered list of views available for a given state, mirroring what's
+ * actually unlocked (Home screen preference, Forest, Cow Pen, Cellar).
+ * Pulled out as a standalone function (rather than only living inline as a
+ * useMemo in useFarmhand.ts) so it can also be used to validate an
+ * externally-supplied view (e.g. from the URL hash) against a specific
+ * state snapshot - which may not be the live, currently-rendered state,
+ * such as a save being loaded during boot or import.
+ */
+export const getViewList = ({
+  isForestUnlocked,
+  purchasedCellar,
+  purchasedCowPen,
+  showHomeScreen,
+}: {
+  isForestUnlocked: boolean
+  purchasedCellar: number
+  purchasedCowPen: number
+  showHomeScreen: boolean
+}): farmhand.stageFocusType[] => {
+  const { CELLAR, COW_PEN, HOME, WORKSHOP, FOREST } = stageFocusType
+  const list: farmhand.stageFocusType[] = [...STANDARD_VIEW_LIST]
+
+  if (showHomeScreen) {
+    list.unshift(HOME)
+  }
+
+  if (isForestUnlocked) {
+    list.push(FOREST)
+  }
+
+  if (purchasedCowPen) {
+    list.push(COW_PEN)
+  }
+
+  list.push(WORKSHOP)
+
+  if (purchasedCellar) {
+    list.push(CELLAR)
+  }
+
+  return list
+}

package/src/utils/hashQueryParams.test.ts

@@ -0,0 +1,153 @@
+import {
+  getHashQueryParams,
+  removeHashQueryParam,
+  setHashQueryParam,
+  withCurrentHashQuery,
+} from './hashQueryParams.js'
+
+describe('hashQueryParams', () => {
+  describe('getHashQueryParams', () => {
+    test('returns an empty URLSearchParams when there is no hash', () => {
+      window.history.replaceState({}, '', `${window.location.pathname}`)
+
+      expect(getHashQueryParams().toString()).toEqual('')
+    })
+
+    test('parses query params from the hash', () => {
+      window.history.replaceState(
+        {},
+        '',
+        `${window.location.pathname}#?view=SHOP&tab=Upgrades`
+      )
+
+      const params = getHashQueryParams()
+
+      expect(params.get('view')).toEqual('SHOP')
+      expect(params.get('tab')).toEqual('Upgrades')
+    })
+
+    test('parses query params from a hash with a router path prefix', () => {
+      window.history.replaceState(
+        {},
+        '',
+        `${window.location.pathname}#online/my-room?view=FIELD`
+      )
+
+      expect(getHashQueryParams().get('view')).toEqual('FIELD')
+    })
+  })
+
+  describe('setHashQueryParam', () => {
+    test('adds a query param to an empty hash', () => {
+      window.history.replaceState({}, '', `${window.location.pathname}`)
+
+      setHashQueryParam('view', 'SHOP')
+
+      expect(window.location.hash).toEqual('#?view=SHOP')
+    })
+
+    test('preserves the hash path prefix', () => {
+      window.history.replaceState(
+        {},
+        '',
+        `${window.location.pathname}#online/my-room`
+      )
+
+      setHashQueryParam('view', 'SHOP')
+
+      expect(window.location.hash).toEqual('#online/my-room?view=SHOP')
+    })
+
+    test('preserves other existing query params', () => {
+      window.history.replaceState(
+        {},
+        '',
+        `${window.location.pathname}#?tab=Upgrades`
+      )
+
+      setHashQueryParam('view', 'SHOP')
+
+      const params = getHashQueryParams()
+
+      expect(params.get('view')).toEqual('SHOP')
+      expect(params.get('tab')).toEqual('Upgrades')
+    })
+
+    test('overwrites an existing value for the same key', () => {
+      window.history.replaceState(
+        {},
+        '',
+        `${window.location.pathname}#?view=SHOP`
+      )
+
+      setHashQueryParam('view', 'FIELD')
+
+      expect(getHashQueryParams().get('view')).toEqual('FIELD')
+    })
+  })
+
+  describe('removeHashQueryParam', () => {
+    test('removes the given key, leaving other params intact', () => {
+      window.history.replaceState(
+        {},
+        '',
+        `${window.location.pathname}#?view=SHOP&tab=Upgrades`
+      )
+
+      removeHashQueryParam('tab')
+
+      const params = getHashQueryParams()
+
+      expect(params.get('view')).toEqual('SHOP')
+      expect(params.has('tab')).toEqual(false)
+    })
+
+    test('drops the "?" entirely when removing the last param', () => {
+      window.history.replaceState(
+        {},
+        '',
+        `${window.location.pathname}#online/my-room?tab=Upgrades`
+      )
+
+      removeHashQueryParam('tab')
+
+      expect(window.location.hash).toEqual('#online/my-room')
+    })
+
+    test('is a no-op when the key is not present', () => {
+      window.history.replaceState(
+        {},
+        '',
+        `${window.location.pathname}#?view=SHOP`
+      )
+
+      removeHashQueryParam('tab')
+
+      expect(window.location.hash).toEqual('#?view=SHOP')
+    })
+  })
+
+  describe('withCurrentHashQuery', () => {
+    test('returns the path unchanged when the hash has no query params', () => {
+      window.history.replaceState(
+        {},
+        '',
+        `${window.location.pathname}#online/my-room`
+      )
+
+      expect(withCurrentHashQuery('/')).toEqual('/')
+    })
+
+    test('appends the current hash query params to the given path', () => {
+      window.history.replaceState(
+        {},
+        '',
+        `${window.location.pathname}#?view=SHOP&tab=Upgrades`
+      )
+
+      expect(withCurrentHashQuery('/online/my-room')).toEqual(
+        '/online/my-room?view=SHOP&tab=Upgrades'
+      )
+    })
+  })
+})

package/src/utils/hashQueryParams.ts

@@ -0,0 +1,72 @@
+import globalWindow from 'global/window.js'
+
+export const VIEW_QUERY_PARAM_NAME = 'view'
+
+// The app is served behind a HashRouter (see src/index.tsx), which owns
+// everything after "#" for its own path-based routing (e.g.
+// "#online/my-room"). These helpers append/read a query string on that
+// same hash, after any router path, so persisted UI state (e.g. the
+// current view) round-trips through a reload without going through
+// react-router's history/location - which requires a <Router> ancestor
+// that isn't present in every test/render context this is used from.
+const splitHash = () => {
+  const hash = globalWindow.location.hash.replace(/^#/, '')
+  const queryIndex = hash.indexOf('?')
+
+  return queryIndex === -1
+    ? { path: hash, query: '' }
+    : { path: hash.slice(0, queryIndex), query: hash.slice(queryIndex + 1) }
+}
+
+export type HashHistoryMode = 'push' | 'replace'
+
+const writeHashQueryParams = (
+  params: URLSearchParams,
+  mode: HashHistoryMode = 'replace'
+): void => {
+  const { path } = splitHash()
+  const queryString = params.toString()
+  const newHash = `${path}${queryString ? `?${queryString}` : ''}`
+  const { origin, pathname, search } = globalWindow.location
+  const url = `${origin}${pathname}${search}#${newHash}`
+
+  if (mode === 'push') {
+    globalWindow.history.pushState({}, '', url)
+  } else {
+    globalWindow.history.replaceState({}, '', url)
+  }
+}
+
+export const getHashQueryParams = (): URLSearchParams =>
+  new URLSearchParams(splitHash().query)
+
+export const setHashQueryParam = (
+  key: string,
+  value: string,
+  mode: HashHistoryMode = 'replace'
+): void => {
+  const params = getHashQueryParams()
+
+  params.set(key, value)
+  writeHashQueryParams(params, mode)
+}
+
+export const removeHashQueryParam = (
+  key: string,
+  mode: HashHistoryMode = 'replace'
+): void => {
+  const params = getHashQueryParams()
+
+  params.delete(key)
+  writeHashQueryParams(params, mode)
+}
+
+// react-router's <Redirect to={path}> replaces the whole hash with `path`,
+// dropping whatever query params (view/tab) were already on it - this
+// carries them over onto a new redirect target (e.g. going online/offline,
+// switching rooms) so navigating doesn't lose your place.
+export const withCurrentHashQuery = (path: string): string => {
+  const queryString = getHashQueryParams().toString()
+
+  return queryString ? `${path}?${queryString}` : path
+}