@ossy/timesheets 3.8.0 → 3.9.0

package/src/generate.task.js

@@ -1,24 +1,21 @@
 import { nanoid } from 'nanoid'
-import { ResourcesEvents, commitResource, mutateResource } from '@ossy/resources/server'
+import { ResourcesEvents, commitResource } from '@ossy/resources/server'
 import { TimesheetsSchema } from './schema-ids.js'
 import { timesheets } from './locations.js'
 import { buildPrefilledLines, monthPeriodBounds } from './build-prefilled-lines.js'
 import { DEFAULT_HOLIDAY_LOCALE, resolveHolidayLocale } from './holiday-locale.js'
-import {
-  findTimesheetForPeriod,
-  getTimesheetResources,
-  toTimesheetDto,
-} from './timesheet-resources.js'
+import { toTimesheetDto, optionalReference } from './timesheet-resources.js'
 
 export const metadata = { id: '@ossy/timesheets/tasks/generate' }
 
 /**
- * Generate (or load) a timesheet for a calendar month.
+ * Generate a new timesheet for a calendar month.
  *
- * Payload: `{ year, monthIndex, locale? }` (monthIndex 0–11) OR `{ periodStart, periodEnd, locale? }`.
+ * Payload: `{ year, monthIndex, locale?, employeeId?, contractId? }` (monthIndex 0–11)
+ * OR `{ periodStart, periodEnd, locale?, employeeId?, contractId? }`.
  * `locale` is an ISO country code or BCP 47 tag used for workday/holiday prefill.
- * If a saved sheet exists for the period, returns it without regenerating.
- * If a draft exists, regenerates prefilled lines (keeps id).
+ * Always creates a new draft — multiple sheets may share the same period.
+ * Optional `employeeId` / `contractId` are stored as `{ resourceId }` references.
  */
 export async function run ({ payload, req, log }) {
   const workspaceId = req?.workspaceId
@@ -53,16 +50,8 @@ export async function run ({ payload, req, log }) {
     `[timesheets/tasks/generate] period ${periodStart}–${periodEnd} for workspace ${workspaceId} (locale ${holidayLocale})`,
   )
 
-  const resources = await getTimesheetResources({
-    schemaId: TimesheetsSchema.timesheet,
-    belongsTo: workspaceId,
-  })
-  const existing = findTimesheetForPeriod(resources, periodStart)
-
-  if (existing?.content?.status === 'saved') {
-    log?.info(`[timesheets/tasks/generate] Returning saved timesheet ${existing.id}`)
-    return toTimesheetDto(existing)
-  }
+  const employeeId = optionalReference(payload?.employeeId)
+  const contractId = optionalReference(payload?.contractId)
 
   const lines = buildPrefilledLines(periodStart, periodEnd, holidayLocale)
   const content = {
@@ -71,18 +60,8 @@ export async function run ({ payload, req, log }) {
     status: 'draft',
     holidayLocale,
     lines,
-  }
-
-  if (existing) {
-    log?.info(`[timesheets/tasks/generate] Regenerating draft ${existing.id}`)
-    await mutateResource(
-      existing.id,
-      ResourcesEvents.Patched({
-        createdBy: req?.userId ?? 'system',
-        content,
-      }),
-    )
-    return toTimesheetDto({ ...existing, content })
+    ...(employeeId ? { employeeId } : {}),
+    ...(contractId ? { contractId } : {}),
   }
 
   const resourceId = nanoid()
@@ -92,7 +71,7 @@ export async function run ({ payload, req, log }) {
     createdBy: req?.userId ?? 'system',
     belongsTo: workspaceId,
     location: timesheets,
-    name: `timesheet-${periodStart}.json`,
+    name: `timesheet-${periodStart}-${resourceId}.json`,
     content,
   })
 

package/src/get.task.js

@@ -9,7 +9,7 @@ import {
 export const metadata = { id: '@ossy/timesheets/tasks/get' }
 
 /**
- * Get a timesheet by `{ timesheetId }` or `{ periodStart }`.
+ * Get a timesheet by `{ timesheetId }` or `{ periodStart }` (newest sheet for that period).
  */
 export async function run ({ payload, req, log }) {
   const workspaceId = req?.workspaceId

package/src/index.js

@@ -1,5 +1,5 @@
 export { Definition } from './Definition.js'
-export { TimesheetsSchema } from './schema-ids.js'
+export { TimesheetsSchema, TimesheetRefs } from './schema-ids.js'
 export {
   location,
   timesheets,
@@ -9,6 +9,7 @@ export { metadata as GenerateTimesheet } from './generate.action.js'
 export { metadata as SaveTimesheet } from './save.action.js'
 export { metadata as ListTimesheets } from './list.action.js'
 export { metadata as GetTimesheet } from './get.action.js'
+export { metadata as DeleteTimesheet } from './delete.action.js'
 export { metadata as OpenNewTimesheet } from './open-new.action.js'
 export { invokeErrorMessage } from './invoke-error-message.js'
 export { downloadTimesheetCsv } from './download-timesheet-csv.js'
@@ -21,3 +22,4 @@ export { TimesheetExportCard } from './TimesheetExportCard.jsx'
 export { TimesheetsFreeTool } from './TimesheetsFreeTool.jsx'
 export { TIMESHEET_EXPORT_BASE_BG } from './export-capture.js'
 export { TimesheetCard } from './TimesheetCard.jsx'
+export { TimesheetPanel } from './TimesheetPanel.jsx'

package/src/list.task.js

@@ -29,7 +29,11 @@ export async function run ({ payload, req, log }) {
 
   const sheets = resources
     .map(toTimesheetDto)
-    .sort((a, b) => (b.periodStart ?? 0) - (a.periodStart ?? 0))
+    .sort((a, b) => {
+      const period = (b.periodStart ?? 0) - (a.periodStart ?? 0)
+      if (period !== 0) return period
+      return (b.createdAt ?? 0) - (a.createdAt ?? 0)
+    })
 
   log?.info(`[timesheets/tasks/list] Found ${sheets.length} timesheet(s)`)
 

package/src/save.task.js

@@ -1,12 +1,12 @@
 import { ResourcesEvents, mutateResource, viewResource } from '@ossy/resources/server'
 import { TimesheetsSchema } from './schema-ids.js'
-import { toTimesheetDto } from './timesheet-resources.js'
+import { toTimesheetDto, optionalReference } from './timesheet-resources.js'
 
 export const metadata = { id: '@ossy/timesheets/tasks/save' }
 
 /**
  * Persist lines and set status to `saved`.
- * Payload: `{ timesheetId, lines }`
+ * Payload: `{ timesheetId, lines, employeeId?, contractId? }`
  */
 export async function run ({ payload, req, log }) {
   const workspaceId = req?.workspaceId
@@ -15,7 +15,7 @@ export async function run ({ payload, req, log }) {
     throw Object.assign(new Error('workspaceId is required'), { status: 400 })
   }
 
-  const { timesheetId, lines } = payload ?? {}
+  const { timesheetId, lines, employeeId: employeePayload, contractId: contractPayload } = payload ?? {}
 
   if (!timesheetId) {
     throw Object.assign(new Error('timesheetId is required'), { status: 400 })
@@ -42,12 +42,23 @@ export async function run ({ payload, req, log }) {
   }))
 
   const content = {
-    periodStart: resource.content?.periodStart,
-    periodEnd: resource.content?.periodEnd,
+    ...resource.content,
     status: 'saved',
     lines: normalizedLines,
   }
 
+  if ('employeeId' in (payload ?? {})) {
+    const employeeId = optionalReference(employeePayload)
+    if (employeeId) content.employeeId = employeeId
+    else delete content.employeeId
+  }
+
+  if ('contractId' in (payload ?? {})) {
+    const contractId = optionalReference(contractPayload)
+    if (contractId) content.contractId = contractId
+    else delete content.contractId
+  }
+
   log?.info(`[timesheets/tasks/save] Saving timesheet ${timesheetId}`)
 
   await mutateResource(

package/src/schema-ids.js

@@ -2,3 +2,9 @@
 export const TimesheetsSchema = Object.freeze({
   timesheet: '@ossy/timesheets/schema/timesheet',
 })
+
+/** Optional document links stored on a timesheet. */
+export const TimesheetRefs = Object.freeze({
+  employee: '@ossy/consultancy/schema/employee',
+  contract: '@ossy/consultancy/schema/contract',
+})

package/src/sv.translations.json

@@ -35,9 +35,15 @@
   "timesheets.createDescription": "Välj en månad och helgdagskalender för att generera en förifylld tidrapport.",
   "timesheets.period": "Period",
   "timesheets.holidayLocale": "Helgdagskalender",
+  "timesheets.employee": "Tilldelad",
+  "timesheets.employeeNone": "Ingen tilldelad",
+  "timesheets.contract": "Kontrakt",
+  "timesheets.contractNone": "Inget kontrakt",
+  "@ossy/timesheets/schema/timesheet.employeeId.label": "Tilldelad",
+  "@ossy/timesheets/schema/timesheet.employeeId.description": "Valfritt. Vem tidrapporten är tilldelad.",
+  "@ossy/timesheets/schema/timesheet.contractId.label": "Kontrakt",
+  "@ossy/timesheets/schema/timesheet.contractId.description": "Valfritt. Kontraktet tidrapporten tillhör.",
   "timesheets.generate": "Generera",
-  "timesheets.openExisting": "Öppna",
-  "timesheets.periodExistsHint": "Det finns redan en tidrapport för perioden — Öppna laddar den.",
   "timesheets.cancel": "Avbryt",
   "timesheets.save": "Spara",
   "timesheets.saving": "Sparar…",
@@ -52,13 +58,26 @@
   "timesheets.listTitle": "Dina tidrapporter",
   "timesheets.listEmpty": "Inga tidrapporter ännu. Klicka på Ny för att generera en för en månad.",
   "timesheets.open": "Öppna",
+  "timesheets.view": "Visa",
+  "timesheets.rowActions": "Åtgärder för tidrapport",
+  "timesheets.delete": "Ta bort",
+  "timesheets.deleteTitle": "Ta bort tidrapporten?",
+  "timesheets.deleteText": "Tidrapporten tas bort. Det går inte att ångra.",
   "timesheets.backToList": "← Alla tidrapporter",
+  "timesheets.closePanel": "Stäng",
   "timesheets.saved": "Tidrapport sparad.",
   "timesheets.unsaved": "Osparade ändringar",
   "timesheets.statusLabel": "Status: {status}",
   "timesheets.status.draft": "Utkast",
   "timesheets.status.saved": "Sparad",
   "timesheets.totalHours": "Totalt: {hours} h",
+  "timesheets.meta.status": "Status",
+  "timesheets.meta.hoursValue": "{hours} h",
+  "timesheets.meta.client": "Kund",
+  "timesheets.meta.hourlyRate": "Timarvode",
+  "timesheets.meta.totalCost": "Totalkostnad",
+  "timesheets.meta.perHour": "/h",
+  "timesheets.meta.dash": "—",
   "timesheets.weekday.mon": "Mån",
   "timesheets.weekday.tue": "Tis",
   "timesheets.weekday.wed": "Ons",
@@ -70,5 +89,6 @@
   "timesheets.errorNotFound": "Tidrapporten hittades inte.",
   "timesheets.errorGenerate": "Kunde inte generera tidrapporten.",
   "timesheets.errorSave": "Kunde inte spara tidrapporten.",
-  "timesheets.errorExport": "Kunde inte exportera tidrapporten."
+  "timesheets.errorExport": "Kunde inte exportera tidrapporten.",
+  "timesheets.errorDelete": "Kunde inte ta bort tidrapporten."
 }

package/src/timesheet-detail.page.jsx

@@ -1,15 +1,5 @@
-import React, { useCallback, useEffect, useRef, useState } from 'react'
-import { Text, View, Button, Page, useLocale, Alert, Dropdown, ContextMenu } from '@ossy/design-system'
+import React, { useEffect } from 'react'
 import { useRouter } from '@ossy/router-react'
-import { useSdk } from '@ossy/sdk-react'
-import { Timesheet } from './Timesheet.jsx'
-import { TimesheetExportCard } from './TimesheetExportCard.jsx'
-import { downloadTimesheetCsv } from './download-timesheet-csv.js'
-import { downloadTimesheetImage } from './download-timesheet-image.js'
-import { downloadTimesheetPdf } from './download-timesheet-pdf.js'
-import { invokeErrorMessage } from './invoke-error-message.js'
-import { metadata as GetTimesheet } from './get.action.js'
-import { metadata as SaveTimesheet } from './save.action.js'
 
 export const metadata = {
   id: 'timesheets/detail',
@@ -20,190 +10,17 @@ export const metadata = {
 }
 
 export default function TimesheetDetailPage () {
-  const { t } = useLocale()
-  const sdk = useSdk()
   const router = useRouter()
   const timesheetId = router.params?.timesheetId
-  const captureRef = useRef(null)
-
-  const [timesheet, setTimesheet] = useState(null)
-  const [lines, setLines] = useState([])
-  const [loading, setLoading] = useState(true)
-  const [saving, setSaving] = useState(false)
-  const [exporting, setExporting] = useState(false)
-  const [error, setError] = useState(null)
-  const [message, setMessage] = useState(null)
-
-  const load = useCallback(async () => {
-    if (!timesheetId) return
-    setLoading(true)
-    setError(null)
-    try {
-      const data = await sdk.invoke(GetTimesheet, { timesheetId })
-      if (!data) {
-        setError(t('timesheets.errorNotFound'))
-        setTimesheet(null)
-        setLines([])
-        return
-      }
-      setTimesheet(data)
-      setLines(data.lines ?? [])
-    } catch (err) {
-      setError(await invokeErrorMessage(err, t('timesheets.errorLoad')))
-      setTimesheet(null)
-      setLines([])
-    } finally {
-      setLoading(false)
-    }
-  }, [sdk, t, timesheetId])
 
   useEffect(() => {
-    load()
-  }, [load])
-
-  const handleSave = async () => {
-    if (!timesheet?.id) return
-    setSaving(true)
-    setError(null)
-    setMessage(null)
-    try {
-      const data = await sdk.invoke(SaveTimesheet, {
-        timesheetId: timesheet.id,
-        lines,
-      })
-      setTimesheet(data)
-      setLines(data?.lines ?? lines)
-      setMessage(t('timesheets.saved'))
-    } catch (err) {
-      setError(await invokeErrorMessage(err, t('timesheets.errorSave')))
-    } finally {
-      setSaving(false)
-    }
-  }
-
-  const exportPayload = {
-    ...timesheet,
-    lines,
-    status: timesheet?.status,
-  }
-
-  const runExport = async (kind) => {
-    if (!lines.length) return
-    setExporting(true)
-    setError(null)
-    setMessage(null)
-    try {
-      if (kind === 'csv') {
-        downloadTimesheetCsv(exportPayload)
-      } else if (kind === 'png') {
-        await downloadTimesheetImage(captureRef.current, exportPayload)
-      } else if (kind === 'pdf') {
-        await downloadTimesheetPdf(captureRef.current, exportPayload)
-      }
-    } catch (err) {
-      setError(await invokeErrorMessage(err, t('timesheets.errorExport')))
-    } finally {
-      setExporting(false)
-    }
-  }
-
-  const homeHref = router.getHref({ id: 'timesheets/home' })
-  const exportDisabled = !lines.length || loading || exporting
-
-  return (
-    <Page
-      title={(
-        <View layout="row" gap="s" alignItems="center">
-          <Button
-            prefix="chevron-left"
-            variant="command"
-            href={homeHref || undefined}
-            aria-label="timesheets.backToList"
-            onClick={homeHref ? undefined : () => router.back()}
-          />
-          <Text variant="heading-default" as="h1" text="timesheets.detail.title" />
-        </View>
-      )}
-      description="timesheets.detail.description"
-      far={(
-        <View layout="row" gap="s" alignItems="center">
-          <Dropdown
-            trigger={(
-              <Button
-                variant="secondary"
-                prefix="software-download"
-                suffix="chevron-down"
-                disabled={exportDisabled}
-              >
-                {exporting ? t('timesheets.exporting') : t('timesheets.export')}
-              </Button>
-            )}
-          >
-            <ContextMenu roundness="s" surface="primary">
-              <ContextMenu.Item
-                prefix="list"
-                label="timesheets.exportCsv"
-                onClick={() => runExport('csv')}
-              />
-              <ContextMenu.Item
-                prefix="image"
-                label="timesheets.exportPng"
-                onClick={() => runExport('png')}
-              />
-              <ContextMenu.Item
-                prefix="file-document"
-                label="timesheets.exportPdf"
-                onClick={() => runExport('pdf')}
-              />
-            </ContextMenu>
-          </Dropdown>
-          <Button
-            id={SaveTimesheet.id}
-            variant="cta"
-            prefix="check"
-            disabled={!timesheet?.id || saving || loading}
-            onClick={handleSave}
-          >
-            {saving ? t('timesheets.saving') : t('timesheets.save')}
-          </Button>
-        </View>
-      )}
-    >
-      <View gap="m">
-        {error && <Alert variant="danger">{error}</Alert>}
-        {message && !error && <Alert variant="success">{message}</Alert>}
-
-        {loading ? (
-          <Text color="secondary" text="timesheets.loading" />
-        ) : timesheet ? (
-          <>
-            <Timesheet
-              lines={lines}
-              onChange={setLines}
-              disabled={loading || saving || exporting}
-              periodStart={timesheet.periodStart}
-            />
-            {/* Off-screen light-theme card for PNG/PDF capture (no inputs). */}
-            <div
-              aria-hidden
-              style={{
-                position: 'fixed',
-                left: 0,
-                top: 0,
-                transform: 'translateX(-200vw)',
-                pointerEvents: 'none',
-                zIndex: -1,
-              }}
-            >
-              <TimesheetExportCard
-                lines={lines}
-                periodStart={timesheet.periodStart}
-                captureRef={captureRef}
-              />
-            </div>
-          </>
-        ) : null}
-      </View>
-    </Page>
-  )
+    const home = router.getHref({ id: 'timesheets/home' }) || '/timesheets'
+    const sep = home.includes('?') ? '&' : '?'
+    const next = timesheetId
+      ? `${home}${sep}r=${encodeURIComponent(timesheetId)}`
+      : home
+    window.location.replace(next)
+  }, [router, timesheetId])
+
+  return null
 }

package/src/timesheet-parties.js

@@ -0,0 +1,57 @@
+import { resourceIdOf } from '@ossy/calendar/holiday-locale'
+
+export { resourceIdOf }
+
+export function employeeLabel (resource) {
+  if (!resource) return ''
+  const name = typeof resource.content?.name === 'string' ? resource.content.name.trim() : ''
+  if (name) return name
+  const docName = typeof resource.name === 'string' ? resource.name.trim() : ''
+  return docName || resource.id || ''
+}
+
+export function contractLabel (resource) {
+  if (!resource) return ''
+  const client = typeof resource.content?.clientName === 'string' ? resource.content.clientName.trim() : ''
+  if (client) return client
+  const docName = typeof resource.name === 'string' ? resource.name.trim() : ''
+  return docName || resource.id || ''
+}
+
+export function labelForEmployee (employees, ref) {
+  const id = resourceIdOf(ref)
+  if (!id || !Array.isArray(employees)) return ''
+  const match = employees.find((resource) => resource.id === id)
+  return match ? employeeLabel(match) : ''
+}
+
+export function labelForContract (contracts, ref) {
+  const id = resourceIdOf(ref)
+  if (!id || !Array.isArray(contracts)) return ''
+  const match = contracts.find((resource) => resource.id === id)
+  return match ? contractLabel(match) : ''
+}
+
+/** Client name and hourly rate from a contract ref, for timesheet meta and exports. */
+export function contractBillingMeta (contracts, ref) {
+  const content = partyContent(findByRef(contracts, ref))
+  if (!content) return { clientName: '', hourlyRate: null }
+  const raw = content.hourlyCompensation
+  const rate = raw == null || raw === '' ? NaN : Number(raw)
+  const clientName = typeof content.clientName === 'string' ? content.clientName.trim() : ''
+  return {
+    clientName,
+    hourlyRate: Number.isFinite(rate) ? rate : null,
+  }
+}
+
+export function findByRef (resources, ref) {
+  const id = resourceIdOf(ref)
+  if (!id || !Array.isArray(resources)) return null
+  return resources.find((resource) => resource.id === id) ?? null
+}
+
+export function partyContent (resource) {
+  if (!resource) return null
+  return { id: resource.id, ...(resource.content || {}) }
+}

package/src/timesheet-parties.spec.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from '@jest/globals'
+import {
+  contractBillingMeta,
+  contractLabel,
+  employeeLabel,
+  findByRef,
+  labelForContract,
+  labelForEmployee,
+} from './timesheet-parties.js'
+
+describe('timesheet party labels', () => {
+  it('prefers content name, then document name', () => {
+    expect(employeeLabel({ id: 'e1', name: 'file.json', content: { name: 'Oskar' } })).toBe('Oskar')
+    expect(employeeLabel({ id: 'e1', name: 'file.json', content: {} })).toBe('file.json')
+    expect(contractLabel({ id: 'c1', content: { clientName: 'Fortnox' } })).toBe('Fortnox')
+  })
+
+  it('resolves labels from a reference', () => {
+    const employees = [{ id: 'e1', content: { name: 'Oskar' } }]
+    const contracts = [{ id: 'c1', content: { clientName: 'Fortnox' } }]
+    expect(labelForEmployee(employees, { resourceId: 'e1' })).toBe('Oskar')
+    expect(labelForContract(contracts, 'c1')).toBe('Fortnox')
+    expect(labelForEmployee(employees, 'missing')).toBe('')
+    expect(findByRef(employees, { resourceId: 'e1' })?.id).toBe('e1')
+  })
+})
+
+describe('contractBillingMeta', () => {
+  it('reads client name and hourly rate', () => {
+    const contracts = [{ id: 'c1', content: { clientName: 'Fortnox', hourlyCompensation: 700 } }]
+    expect(contractBillingMeta(contracts, 'c1')).toEqual({
+      clientName: 'Fortnox',
+      hourlyRate: 700,
+    })
+    expect(contractBillingMeta(contracts, 'missing')).toEqual({
+      clientName: '',
+      hourlyRate: null,
+    })
+  })
+})

package/src/timesheet-resources.js

@@ -9,8 +9,28 @@ export function getTimesheetResources ({ schemaId, belongsTo } = {}) {
   return ResourcesQueries.GetResources(query)
 }
 
+/** Newest sheet for a period. Generate always creates a new resource; use get-by-id for a specific sheet. */
 export function findTimesheetForPeriod (resources, periodStart) {
-  return (resources || []).find((r) => r.content?.periodStart === periodStart) ?? null
+  const matches = (resources || []).filter((r) => r.content?.periodStart === periodStart)
+  if (matches.length === 0) return null
+  return [...matches].sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0))[0]
+}
+
+/**
+ * Normalize an optional document reference to `{ resourceId }` or `null`.
+ * Accepts a stored object, a plain id string, or empty.
+ */
+export function optionalReference (value) {
+  if (value == null || value === '') return null
+  if (typeof value === 'string') {
+    const id = value.trim()
+    return id ? { resourceId: id } : null
+  }
+  if (typeof value === 'object' && typeof value.resourceId === 'string') {
+    const id = value.resourceId.trim()
+    return id ? { resourceId: id } : null
+  }
+  return null
 }
 
 export function toTimesheetDto (resource) {
@@ -21,6 +41,8 @@ export function toTimesheetDto (resource) {
     periodEnd: resource.content?.periodEnd,
     status: resource.content?.status ?? 'draft',
     holidayLocale: resource.content?.holidayLocale ?? null,
+    employeeId: optionalReference(resource.content?.employeeId),
+    contractId: optionalReference(resource.content?.contractId),
     lines: resource.content?.lines ?? [],
     createdAt: resource.createdAt,
     updatedAt: resource.updatedAt,

package/src/timesheet-resources.spec.js

@@ -0,0 +1,59 @@
+import { describe, expect, it } from '@jest/globals'
+import {
+  findTimesheetForPeriod,
+  optionalReference,
+  toTimesheetDto,
+} from './timesheet-resources.js'
+
+describe('optionalReference', () => {
+  it('normalizes ids, objects, and empty values', () => {
+    expect(optionalReference(' emp-1 ')).toEqual({ resourceId: 'emp-1' })
+    expect(optionalReference({ resourceId: 'emp-1' })).toEqual({ resourceId: 'emp-1' })
+    expect(optionalReference('')).toBe(null)
+    expect(optionalReference(null)).toBe(null)
+    expect(optionalReference({})).toBe(null)
+  })
+})
+
+describe('toTimesheetDto', () => {
+  it('includes optional employee and contract refs', () => {
+    expect(toTimesheetDto({
+      id: 'sheet-1',
+      content: {
+        periodStart: 1,
+        periodEnd: 2,
+        status: 'draft',
+        holidayLocale: 'SE',
+        employeeId: 'emp-1',
+        contractId: { resourceId: 'con-1' },
+        lines: [],
+      },
+      createdAt: 10,
+      updatedAt: 20,
+    })).toEqual({
+      id: 'sheet-1',
+      periodStart: 1,
+      periodEnd: 2,
+      status: 'draft',
+      holidayLocale: 'SE',
+      employeeId: { resourceId: 'emp-1' },
+      contractId: { resourceId: 'con-1' },
+      lines: [],
+      createdAt: 10,
+      updatedAt: 20,
+    })
+  })
+})
+
+describe('findTimesheetForPeriod', () => {
+  it('returns the newest sheet when several share a period', () => {
+    const resources = [
+      { id: 'old', createdAt: 1, content: { periodStart: 100 } },
+      { id: 'new', createdAt: 3, content: { periodStart: 100 } },
+      { id: 'mid', createdAt: 2, content: { periodStart: 100 } },
+      { id: 'other', createdAt: 9, content: { periodStart: 200 } },
+    ]
+    expect(findTimesheetForPeriod(resources, 100)?.id).toBe('new')
+    expect(findTimesheetForPeriod(resources, 999)).toBe(null)
+  })
+})