@ossy/timesheets 3.0.6 → 3.0.7

package/src/generate.task.js

@@ -0,0 +1,103 @@
+import { nanoid } from 'nanoid'
+import { ResourcesEvents, commitResource, mutateResource } 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'
+
+export const metadata = { id: '@ossy/timesheets/tasks/generate' }
+
+/**
+ * Generate (or load) a timesheet for a calendar month.
+ *
+ * Payload: `{ year, monthIndex, locale? }` (monthIndex 0–11) OR `{ periodStart, periodEnd, locale? }`.
+ * `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).
+ */
+export async function run ({ payload, req, log }) {
+  const workspaceId = req?.workspaceId
+
+  if (!workspaceId) {
+    throw Object.assign(new Error('workspaceId is required'), { status: 400 })
+  }
+
+  const { year, monthIndex, locale: payloadLocale } = payload ?? {}
+  let { periodStart, periodEnd } = payload ?? {}
+
+  if (periodStart == null || periodEnd == null) {
+    if (year == null || monthIndex == null) {
+      throw Object.assign(
+        new Error('year and monthIndex (or periodStart and periodEnd) are required'),
+        { status: 400 },
+      )
+    }
+    ;({ periodStart, periodEnd } = monthPeriodBounds(Number(year), Number(monthIndex)))
+  }
+
+  periodStart = Number(periodStart)
+  periodEnd = Number(periodEnd)
+
+  if (!Number.isFinite(periodStart) || !Number.isFinite(periodEnd) || periodEnd < periodStart) {
+    throw Object.assign(new Error('invalid period'), { status: 400 })
+  }
+
+  const holidayLocale = resolveHolidayLocale(payloadLocale, DEFAULT_HOLIDAY_LOCALE)
+
+  log?.info(
+    `[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 lines = buildPrefilledLines(periodStart, periodEnd, holidayLocale)
+  const content = {
+    periodStart,
+    periodEnd,
+    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 })
+  }
+
+  const resourceId = nanoid()
+  const event = ResourcesEvents.Created({
+    resourceId,
+    schemaId: TimesheetsSchema.timesheet,
+    createdBy: req?.userId ?? 'system',
+    belongsTo: workspaceId,
+    location: timesheets,
+    name: `timesheet-${periodStart}.json`,
+    content,
+  })
+
+  const created = await commitResource(event)
+  log?.info(`[timesheets/tasks/generate] Created timesheet ${resourceId}`)
+
+  return toTimesheetDto({ id: resourceId, content, ...created })
+}

package/src/get.action.js

@@ -0,0 +1,4 @@
+export const metadata = {
+  id: '@ossy/timesheets/actions/get',
+  access: 'workspace',
+}

package/src/get.task.js

@@ -0,0 +1,56 @@
+import { viewResource } from '@ossy/resources/server'
+import { TimesheetsSchema } from './schema-ids.js'
+import {
+  findTimesheetForPeriod,
+  getTimesheetResources,
+  toTimesheetDto,
+} from './timesheet-resources.js'
+
+export const metadata = { id: '@ossy/timesheets/tasks/get' }
+
+/**
+ * Get a timesheet by `{ timesheetId }` or `{ periodStart }`.
+ */
+export async function run ({ payload, req, log }) {
+  const workspaceId = req?.workspaceId
+
+  if (!workspaceId) {
+    throw Object.assign(new Error('workspaceId is required'), { status: 400 })
+  }
+
+  const { timesheetId, periodStart } = payload ?? {}
+
+  if (timesheetId) {
+    log?.info(`[timesheets/tasks/get] Loading timesheet ${timesheetId}`)
+    const resource = await viewResource(timesheetId)
+
+    if (!resource || resource.type !== TimesheetsSchema.timesheet) {
+      return null
+    }
+
+    if (resource.belongsTo && resource.belongsTo !== workspaceId) {
+      return null
+    }
+
+    return toTimesheetDto(resource)
+  }
+
+  if (periodStart == null) {
+    throw Object.assign(
+      new Error('timesheetId or periodStart is required'),
+      { status: 400 },
+    )
+  }
+
+  const resources = await getTimesheetResources({
+    schemaId: TimesheetsSchema.timesheet,
+    belongsTo: workspaceId,
+  })
+  const existing = findTimesheetForPeriod(resources, Number(periodStart))
+
+  log?.info(
+    `[timesheets/tasks/get] period ${periodStart} → ${existing?.id ?? 'not found'}`,
+  )
+
+  return toTimesheetDto(existing)
+}

package/src/holiday-locale.js

@@ -0,0 +1,64 @@
+/**
+ * Map UI language / BCP 47 tags to ISO 3166-1 alpha-2 country codes
+ * for `date-holidays` (CalendarClient.isWorkDay).
+ *
+ * Prefer an explicit region (`sv-SE` → `SE`, `en-US` → `US`).
+ * Language-only tags fall back to a common country for that language.
+ */
+
+/** @type {Record<string, string>} */
+const LANGUAGE_TO_COUNTRY = {
+  sv: 'SE',
+  en: 'GB',
+  nb: 'NO',
+  nn: 'NO',
+  no: 'NO',
+  da: 'DK',
+  fi: 'FI',
+  de: 'DE',
+  fr: 'FR',
+  nl: 'NL',
+  es: 'ES',
+  it: 'IT',
+  pt: 'PT',
+  pl: 'PL',
+}
+
+const DEFAULT_HOLIDAY_LOCALE = 'SE'
+
+/**
+ * @param {unknown} value
+ * @returns {string | null} Uppercase ISO country code, or null if invalid
+ */
+export function normalizeHolidayLocale (value) {
+  if (typeof value !== 'string') return null
+  const trimmed = value.trim()
+  if (!/^[A-Za-z]{2}$/.test(trimmed)) return null
+  return trimmed.toUpperCase()
+}
+
+/**
+ * @param {string | null | undefined} languageOrTag UI language or BCP 47 tag
+ * @param {string} [fallback]
+ * @returns {string} ISO country code for holiday calendars
+ */
+export function resolveHolidayLocale (languageOrTag, fallback = DEFAULT_HOLIDAY_LOCALE) {
+  if (typeof languageOrTag === 'string' && languageOrTag.trim()) {
+    try {
+      const loc = new Intl.Locale(languageOrTag.trim())
+      const region = normalizeHolidayLocale(loc.region)
+      if (region) return region
+      const fromLanguage = LANGUAGE_TO_COUNTRY[loc.language?.toLowerCase()]
+      if (fromLanguage) return fromLanguage
+    } catch {
+      // fall through
+    }
+
+    const asCountry = normalizeHolidayLocale(languageOrTag)
+    if (asCountry) return asCountry
+  }
+
+  return normalizeHolidayLocale(fallback) || DEFAULT_HOLIDAY_LOCALE
+}
+
+export { DEFAULT_HOLIDAY_LOCALE }

package/src/index.js

@@ -1 +1,23 @@
 export { Definition } from './Definition.js'
+export { TimesheetsSchema } from './schema-ids.js'
+export {
+  location,
+  timesheets,
+  locationByType,
+} from './locations.js'
+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 OpenNewTimesheet } from './open-new.action.js'
+export { invokeErrorMessage } from './invoke-error-message.js'
+export { downloadTimesheetCsv } from './download-timesheet-csv.js'
+export { downloadTimesheetImage } from './download-timesheet-image.js'
+export { downloadTimesheetPdf } from './download-timesheet-pdf.js'
+export { buildPrefilledLines, monthPeriodBounds, WORKDAY_HOURS } from './build-prefilled-lines.js'
+export { resolveHolidayLocale, DEFAULT_HOLIDAY_LOCALE } from './holiday-locale.js'
+export { Timesheet } from './Timesheet.jsx'
+export { TimesheetExportCard } from './TimesheetExportCard.jsx'
+export { TimesheetsFreeTool } from './TimesheetsFreeTool.jsx'
+export { TIMESHEET_EXPORT_BASE_BG } from './export-capture.js'
+export { TimesheetCard } from './TimesheetCard.jsx'

package/src/invoke-error-message.js

@@ -0,0 +1,10 @@
+/** Normalize errors from `sdk.invoke` (Response, string, or Error). */
+export async function invokeErrorMessage (err, fallback) {
+  if (typeof err === 'string') return err
+  if (err instanceof Response) {
+    const data = await err.json().catch(() => ({}))
+    return data?.message ?? data?.error ?? fallback
+  }
+  if (err instanceof Error) return err.message ?? fallback
+  return fallback
+}

package/src/list.action.js

@@ -0,0 +1,4 @@
+export const metadata = {
+  id: '@ossy/timesheets/actions/list',
+  access: 'workspace',
+}

package/src/list.task.js

@@ -0,0 +1,37 @@
+import { TimesheetsSchema } from './schema-ids.js'
+import { getTimesheetResources, toTimesheetDto } from './timesheet-resources.js'
+
+export const metadata = { id: '@ossy/timesheets/tasks/list' }
+
+/**
+ * List timesheets for the workspace. Optional `{ periodStart }` filter.
+ */
+export async function run ({ payload, req, log }) {
+  const workspaceId = req?.workspaceId
+
+  if (!workspaceId) {
+    throw Object.assign(new Error('workspaceId is required'), { status: 400 })
+  }
+
+  const { periodStart } = payload ?? {}
+
+  log?.info(`[timesheets/tasks/list] Listing timesheets for workspace ${workspaceId}`)
+
+  let resources = await getTimesheetResources({
+    schemaId: TimesheetsSchema.timesheet,
+    belongsTo: workspaceId,
+  })
+
+  if (periodStart != null) {
+    const ps = Number(periodStart)
+    resources = resources.filter((r) => r.content?.periodStart === ps)
+  }
+
+  const sheets = resources
+    .map(toTimesheetDto)
+    .sort((a, b) => (b.periodStart ?? 0) - (a.periodStart ?? 0))
+
+  log?.info(`[timesheets/tasks/list] Found ${sheets.length} timesheet(s)`)
+
+  return sheets
+}

package/src/locations.js

@@ -0,0 +1,11 @@
+import { TimesheetsSchema } from './schema-ids.js'
+
+/** Timesheets feature root. */
+export const location = '/@ossy/timesheets/'
+
+/** Canonical location for timesheet documents. */
+export const timesheets = '/@ossy/timesheets/sheets/'
+
+export const locationByType = {
+  [TimesheetsSchema.timesheet]: timesheets,
+}

package/src/open-new.action.js

@@ -0,0 +1,5 @@
+export const metadata = {
+  id: '@ossy/timesheets/actions/open-new',
+  access: 'workspace',
+  label: 'timesheets.new',
+}

package/src/sample-showcase-timesheet.js

@@ -0,0 +1,34 @@
+import { buildPrefilledLines, monthPeriodBounds } from './build-prefilled-lines.js'
+
+/**
+ * Demo timesheet for the sales hero — current month, locale-aware holidays,
+ * with a couple of workdays nudged so it looks reviewed.
+ *
+ * @param {string | null | undefined} language UI language / BCP 47 tag
+ * @returns {{ periodStart: number, periodEnd: number, lines: Array<{ date: number, hours: number, isWorkday: boolean }> }}
+ */
+export function sampleShowcaseTimesheet (language) {
+  const now = new Date()
+  const { periodStart, periodEnd } = monthPeriodBounds(now.getFullYear(), now.getMonth())
+  const lines = buildPrefilledLines(periodStart, periodEnd, language)
+
+  const workdayIndexes = []
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].isWorkday) workdayIndexes.push(i)
+  }
+
+  // Nudge mid-month workdays so the preview looks adjusted, not blank-perfect.
+  const tweakTargets = [
+    { offset: Math.floor(workdayIndexes.length * 0.35), hours: 6 },
+    { offset: Math.floor(workdayIndexes.length * 0.55), hours: 4 },
+  ]
+
+  for (const { offset, hours } of tweakTargets) {
+    const idx = workdayIndexes[offset]
+    if (idx != null) {
+      lines[idx] = { ...lines[idx], hours }
+    }
+  }
+
+  return { periodStart, periodEnd, lines }
+}

package/src/save.action.js

@@ -0,0 +1,5 @@
+export const metadata = {
+  id: '@ossy/timesheets/actions/save',
+  access: 'workspace',
+  label: 'timesheets.save',
+}

package/src/save.task.js

@@ -0,0 +1,62 @@
+import { ResourcesEvents, mutateResource, viewResource } from '@ossy/resources/server'
+import { TimesheetsSchema } from './schema-ids.js'
+import { toTimesheetDto } from './timesheet-resources.js'
+
+export const metadata = { id: '@ossy/timesheets/tasks/save' }
+
+/**
+ * Persist lines and set status to `saved`.
+ * Payload: `{ timesheetId, lines }`
+ */
+export async function run ({ payload, req, log }) {
+  const workspaceId = req?.workspaceId
+
+  if (!workspaceId) {
+    throw Object.assign(new Error('workspaceId is required'), { status: 400 })
+  }
+
+  const { timesheetId, lines } = payload ?? {}
+
+  if (!timesheetId) {
+    throw Object.assign(new Error('timesheetId is required'), { status: 400 })
+  }
+
+  if (!Array.isArray(lines)) {
+    throw Object.assign(new Error('lines must be an array'), { status: 400 })
+  }
+
+  const resource = await viewResource(timesheetId)
+
+  if (!resource || resource.type !== TimesheetsSchema.timesheet) {
+    throw Object.assign(new Error('timesheet not found'), { status: 404 })
+  }
+
+  if (resource.belongsTo && resource.belongsTo !== workspaceId) {
+    throw Object.assign(new Error('timesheet not found'), { status: 404 })
+  }
+
+  const normalizedLines = lines.map((line) => ({
+    date: Number(line.date),
+    hours: Number(line.hours) || 0,
+    isWorkday: Boolean(line.isWorkday),
+  }))
+
+  const content = {
+    periodStart: resource.content?.periodStart,
+    periodEnd: resource.content?.periodEnd,
+    status: 'saved',
+    lines: normalizedLines,
+  }
+
+  log?.info(`[timesheets/tasks/save] Saving timesheet ${timesheetId}`)
+
+  await mutateResource(
+    timesheetId,
+    ResourcesEvents.Patched({
+      createdBy: req?.userId ?? 'system',
+      content,
+    }),
+  )
+
+  return toTimesheetDto({ ...resource, id: timesheetId, content })
+}

package/src/schema-ids.js

@@ -0,0 +1,4 @@
+/** Canonical schema ids for @ossy/timesheets (ADR 0006). */
+export const TimesheetsSchema = Object.freeze({
+  timesheet: '@ossy/timesheets/schema/timesheet',
+})

package/src/sv.translations.json

@@ -1,5 +1,73 @@
 {
   "timesheets/home.documentTitle": "Tidrapportering",
+  "timesheets/detail.documentTitle": "Tidrapport",
   "timesheets.home.title": "Tidrapportering",
-  "timesheets.home.description": "Hantera tidrapporter för ditt team. Skapa nya tidrapporter, redigera befintliga och ta bort tidrapporter du inte längre behöver."
+  "timesheets.nav.title": "Tidrapportering",
+  "timesheets.home.description": "Dina månatliga tidrapporter. Skapa en, granska timmar i kalendern, spara och exportera.",
+  "timesheets.catalog.pitch": "Testa gratis — justera och exportera månadstimmar; skapa konto för att spara",
+  "timesheets.home.cover.title": "Månadsvisa tidrapporter som är förifyllda",
+  "timesheets.home.cover.text": "Generera en månad med timmar, justera det som skiljer sig, spara och exportera som CSV, bild eller PDF.",
+  "timesheets.home.cover.ctaPrimary": "Kom igång gratis",
+  "timesheets.home.cover.ctaSecondary": "Testa gratis",
+  "timesheets.freeTool.sectionTitle": "Testa gratis",
+  "timesheets.freeTool.sectionDescription": "Justera den här månadens timmar och exportera som CSV, bild eller PDF. Inget sparas förrän du skapar konto.",
+  "timesheets.freeTool.saveCta": "Skapa konto för att spara",
+  "timesheets.freeTool.saveHint": "Ändringar stannar i den här webbläsaren tills du laddar om. Exportera när du vill — spara kräver konto.",
+  "timesheets.freeTool.saveHintAuthenticated": "Exportera när du vill. Aktivera tidrapportering i workspace för att spara månader permanent.",
+  "timesheets.freeTool.signInLink": "Har du redan konto? Logga in",
+  "timesheets.home.features.prefill.title": "Förifyll månaden",
+  "timesheets.home.features.prefill.text": "Arbetsdagar börjar på 8 timmar. Helger och röda dagar nollas och markeras — ingen tom kalkylarksmall.",
+  "timesheets.home.features.review.title": "Granska i kalender",
+  "timesheets.home.features.review.text": "Redigera timmar dag för dag på ett månadskort. Ändra bara det som skiljer sig från standard.",
+  "timesheets.home.features.export.title": "Exportera när du är klar",
+  "timesheets.home.features.export.text": "Ladda ner CSV för kalkylark, eller PNG och PDF som matchar kalenderkortet.",
+  "timesheets.home.features.calendar.title": "Kalenderanpassad",
+  "timesheets.home.features.calendar.text": "Arbetsdagar och helgdagar räknas ut utifrån din region — helger nollas som standard.",
+  "timesheets.sales.overview": "Översikt",
+  "timesheets.sales.features": "Funktioner",
+  "timesheets.sales.enable": "Aktivera tidrapportering",
+  "timesheets.sales.enableDescription": "Aktivera tidrapportering för ditt workspace så du kan generera, spara och exportera månatlig arbetstid.",
+  "timesheets.sales.enableError": "Kunde inte aktivera tidrapportering. Försök igen eller kontakta support.",
+  "timesheets.detail.title": "Tidrapport",
+  "timesheets.detail.description": "Granska och justera timmar, spara eller exportera.",
+  "timesheets.new": "Ny",
+  "timesheets.createTitle": "Ny tidrapport",
+  "timesheets.createDescription": "Välj en månad för att generera en förifylld tidrapport.",
+  "timesheets.period": "Period",
+  "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…",
+  "timesheets.loading": "Laddar…",
+  "timesheets.export": "Exportera",
+  "timesheets.exporting": "Exporterar…",
+  "timesheets.exportCsv": "CSV",
+  "timesheets.exportPng": "Bild (PNG)",
+  "timesheets.exportPdf": "PDF",
+  "timesheets.hours": "Timmar",
+  "timesheets.empty": "Inga dagar i den här tidrapporten.",
+  "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.backToList": "← Alla tidrapporter",
+  "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.weekday.mon": "Mån",
+  "timesheets.weekday.tue": "Tis",
+  "timesheets.weekday.wed": "Ons",
+  "timesheets.weekday.thu": "Tor",
+  "timesheets.weekday.fri": "Fre",
+  "timesheets.weekday.sat": "Lör",
+  "timesheets.weekday.sun": "Sön",
+  "timesheets.errorLoad": "Kunde inte ladda tidrapporten.",
+  "timesheets.errorNotFound": "Tidrapporten hittades inte.",
+  "timesheets.errorGenerate": "Kunde inte generera tidrapporten.",
+  "timesheets.errorSave": "Kunde inte spara tidrapporten.",
+  "timesheets.errorExport": "Kunde inte exportera tidrapporten."
 }