Files
accounted/lib/bokslut/accruals/date-range-parser.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i
server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma
strängvärde byggs med konkatenering i stället för att matcha mönstret.
2026-11-10 09:37:22 +01:00

178 lines
6.0 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* Parses Swedish (and a few mixed Swedish/English) date-range patterns out
* of free-text invoice descriptions / line items so the periodisering wizard
* can auto-detect supplier invoices and customer invoices whose service
* window crosses the fiscal-period boundary.
*
* The function is intentionally conservative: it only returns a parse when
* BOTH a recognizable start and end date are present. Single dates, "från
* 2026-01-01" with no end, and malformed strings all return null. The auto-
* detect step later sets `confidence: 'low'` when the parser only caught a
* partial pattern (currently always "high" since partials return null,
* kept as a knob so the wizard UI can downgrade future heuristics without
* touching this file).
*
* Patterns supported (case-insensitive):
* 1. ISO : "period: 2026-01-01 till 2027-12-31"
* 2. ISO : "perioden 2026-01-01 - 2026-12-31"
* 3. Swede : "period: 1 jan 2026 - 31 dec 2026"
* 4. Swede : "jan 2026 till dec 2026" (whole-month range, expanded to 1st / last)
* 5. yyyy-mm: "2026-01 till 2027-12" (expanded to 1st of start / last of end)
* 6. Free : "giltig från 2026-01-01 till 2027-12-31"
*
* All return ISO `yyyy-mm-dd`. The function does no fiscal logic: it just
* reports the parsed window. The caller decides whether endDate > period_end.
*/
const SWEDISH_MONTHS: Record<string, number> = {
jan: 0,
januari: 0,
feb: 1,
februari: 1,
mar: 2,
mars: 2,
apr: 3,
april: 3,
maj: 4,
jun: 5,
juni: 5,
jul: 6,
juli: 6,
aug: 7,
augusti: 7,
sep: 8,
september: 8,
okt: 9,
oktober: 9,
nov: 10,
november: 10,
dec: 11,
december: 11,
}
const MONTH_NAMES_PATTERN = Object.keys(SWEDISH_MONTHS).join('|')
/** Separator tokens between the two dates: " till ", " - ", "–", "—". */
const SEP = '(?:\\s*[-–—]\\s*|\\s+till\\s+|\\s+t\\.?\\s*o\\.?\\s*m\\.?\\s+)'
/** ISO date `yyyy-mm-dd`. */
const ISO = '(\\d{4}-\\d{2}-\\d{2})'
/** yyyy-mm without day. */
const YM = '(\\d{4}-\\d{2})'
/** Swedish long form "1 jan 2026": day optional. */
const SWE_LONG = `(?:(\\d{1,2})\\s+)?(${MONTH_NAMES_PATTERN})\\s+(\\d{4})`
function pad2(n: number): string {
return n < 10 ? `0${n}` : String(n)
}
/** Number of days in a (1-based) month/year, honoring leap years. */
function daysInMonth(year: number, monthZeroBased: number): number {
return new Date(Date.UTC(year, monthZeroBased + 1, 0)).getUTCDate()
}
function isoFromYMD(year: number, monthZeroBased: number, day: number): string {
return `${year}-${pad2(monthZeroBased + 1)}-${pad2(day)}`
}
/** "2026-01" → "2026-01-01"; "2026-02" with `lastDay=true` → "2026-02-28". */
function expandYearMonth(ym: string, lastDay: boolean): string | null {
const m = /^(\d{4})-(\d{2})$/.exec(ym)
if (!m) return null
const year = parseInt(m[1], 10)
const monthZero = parseInt(m[2], 10) - 1
if (monthZero < 0 || monthZero > 11) return null
const day = lastDay ? daysInMonth(year, monthZero) : 1
return isoFromYMD(year, monthZero, day)
}
/** Swedish long form ("1 jan 2026" or "jan 2026") → ISO. When the day is
* missing, anchor to the 1st (start side) or the last day of the month
* (end side). */
function expandSwedishLong(
day: string | undefined,
monthName: string,
year: string,
endSide: boolean,
): string | null {
const monthZero = SWEDISH_MONTHS[monthName.toLowerCase()]
if (monthZero === undefined) return null
const y = parseInt(year, 10)
if (Number.isNaN(y)) return null
if (day) {
const d = parseInt(day, 10)
if (d < 1 || d > daysInMonth(y, monthZero)) return null
return isoFromYMD(y, monthZero, d)
}
return isoFromYMD(y, monthZero, endSide ? daysInMonth(y, monthZero) : 1)
}
function validateRange(startDate: string, endDate: string): boolean {
// endDate must be strictly after startDate. A single date repeated isn't
// a range, just a point: the caller should treat that as "no range".
return endDate > startDate
}
export interface ParsedDateRange {
startDate: string // ISO yyyy-mm-dd
endDate: string // ISO yyyy-mm-dd
}
/**
* Attempt to extract a date range from a free-text description. Returns
* null if nothing recognizable is found.
*/
export function parseInvoiceDateRange(description: string | null | undefined): ParsedDateRange | null {
if (!description) return null
const text = description.toLowerCase()
// 1. ISO-ISO: "2026-01-01 till 2027-12-31", "2026-01-01 - 2027-12-31"
const isoRe = new RegExp(`${ISO}${SEP}${ISO}`, 'i')
const isoMatch = isoRe.exec(text)
if (isoMatch) {
const start = isoMatch[1]
const end = isoMatch[2]
if (isValidIso(start) && isValidIso(end) && validateRange(start, end)) {
return { startDate: start, endDate: end }
}
}
// 2. Swedish long form on both sides: "1 jan 2026 - 31 dec 2026"
const sweRe = new RegExp(`${SWE_LONG}${SEP}${SWE_LONG}`, 'i')
const sweMatch = sweRe.exec(text)
if (sweMatch) {
const startDate = expandSwedishLong(sweMatch[1], sweMatch[2], sweMatch[3], false)
const endDate = expandSwedishLong(sweMatch[4], sweMatch[5], sweMatch[6], true)
if (startDate && endDate && validateRange(startDate, endDate)) {
return { startDate, endDate }
}
}
// 3. yyyy-mm on both sides: "2026-01 till 2027-12"
// Guarded: don't allow a full ISO date here, anchor to space / start.
const ymRe = new RegExp(`(?:^|[^\\d-])${YM}${SEP}${YM}(?![\\d-])`, 'i')
const ymMatch = ymRe.exec(text)
if (ymMatch) {
const startDate = expandYearMonth(ymMatch[1], false)
const endDate = expandYearMonth(ymMatch[2], true)
if (startDate && endDate && validateRange(startDate, endDate)) {
return { startDate, endDate }
}
}
return null
}
function isValidIso(s: string): boolean {
if (!/^\d{4}-\d{2}-\d{2}$/.test(s)) return false
const [yStr, mStr, dStr] = s.split('-')
const year = parseInt(yStr, 10)
const monthZero = parseInt(mStr, 10) - 1
const day = parseInt(dStr, 10)
if (monthZero < 0 || monthZero > 11) return false
if (day < 1 || day > daysInMonth(year, monthZero)) return false
return true
}