@remato/personal-code-to-birthday 0.0.0 → 1.1.0

package/README.md

@@ -28,21 +28,21 @@ console.log(birthday) // outputs { day: 26, month: 9, year: 1993 }
 -   🇸🇪 Sweden
 -   🇳🇴 Norway
 -   🇩🇰 Denmark
+-   🇺🇦 Ukraine
+-   🇵🇱 Poland
 
 Countries we would like to support (PRs are welcome):
 
 -   Iceland
--   South Africa
 -   Romania
 -   Hungary
 -   Bulgaria
+-   Moldova
+-   Azerbaijan
 -   North Macedonia
 -   Czech Republic
 -   Slovakia
--   Poland
 -   South Korea
 -   Turkey
--   Moldova
--   Azerbaijan
+-   South Africa
 -   Russia
--   Ukraine

package/package.json

@@ -1,11 +1,11 @@
 {
 	"name": "@remato/personal-code-to-birthday",
-	"version": "0.0.0",
+	"version": "1.1.0",
 	"description": "Converts personal identification codes from various countries into birthdate",
 	"license": "MIT",
-	"main": "index.ts",
+	"main": "src/index.ts",
 	"scripts": {
-		"build": "ncc build index.ts",
+		"build": "ncc build src/index.ts",
 		"test": "jest",
 		"prettier": "prettier --list-different \"**/*.ts\"",
 		"lint": "eslint \"**/*.ts\""
@@ -40,7 +40,7 @@
 		},
 		"collectCoverage": true,
 		"collectCoverageFrom": [
-			"index.ts"
+			"src/**"
 		]
 	},
 	"eslintConfig": {

package/{index.test.ts → src/index.test.ts}

@@ -2,8 +2,10 @@ import personalCodeToBirthday from './index'
 
 describe('valid codes', () => {
 	test('Estonia', () => {
-		expect(personalCodeToBirthday('39405280299')).toEqual({ day: 28, month: 5, year: 1994 })
-		expect(personalCodeToBirthday('60105280299')).toEqual({ day: 28, month: 5, year: 2001 })
+		expect(personalCodeToBirthday('39309262754')).toEqual({ day: 26, month: 9, year: 1993 })
+		expect(personalCodeToBirthday('49111012217')).toEqual({ day: 1, month: 11, year: 1991 })
+		expect(personalCodeToBirthday('30001010060')).toEqual({ day: 1, month: 1, year: 1900 })
+		expect(personalCodeToBirthday('62305060020')).toEqual({ day: 6, month: 5, year: 2023 })
 	})
 
 	test('Latvia', () => {
@@ -12,7 +14,7 @@ describe('valid codes', () => {
 	})
 
 	test('Lithuania', () => {
-		expect(personalCodeToBirthday('39905280217')).toEqual({ day: 28, month: 5, year: 1999 })
+		expect(personalCodeToBirthday('39905280216')).toEqual({ day: 28, month: 5, year: 1999 })
 	})
 
 	test('Finland', () => {
@@ -31,17 +33,27 @@ describe('valid codes', () => {
 	})
 
 	test('Denmark', () => {
-		expect(personalCodeToBirthday('0503054567')).toEqual({ day: 5, month: 3, year: 2005 })
-		expect(personalCodeToBirthday('0503841235')).toEqual({ day: 5, month: 3, year: 1984 })
+		expect(personalCodeToBirthday('050305-4567')).toEqual({ day: 5, month: 3, year: 2005 })
 		expect(personalCodeToBirthday('050384-1235')).toEqual({ day: 5, month: 3, year: 1984 })
-		expect(personalCodeToBirthday('0503844567')).toEqual({ day: 5, month: 3, year: 1984 })
+		expect(personalCodeToBirthday('050384-4567')).toEqual({ day: 5, month: 3, year: 1984 })
+	})
+
+	test('Ukraine', () => {
+		expect(personalCodeToBirthday('3406105372')).toEqual({ day: 3, month: 4, year: 1993 })
+		expect(personalCodeToBirthday('3406105350')).toEqual({ day: 3, month: 4, year: 1993 })
+	})
+
+	test('Poland', () => {
+		expect(personalCodeToBirthday('44051401359')).toEqual({ day: 14, month: 5, year: 1944 })
+		expect(personalCodeToBirthday('02070803628')).toEqual({ day: 8, month: 7, year: 1902 })
+		expect(personalCodeToBirthday('24231012344')).toEqual({ day: 10, month: 3, year: 2024 })
 	})
 })
 
 describe('invalid personal code', () => {
 	test('Estonia', () => {
-		const result = personalCodeToBirthday('39913025555')
-		expect(result).toBeNull()
+		expect(personalCodeToBirthday('39911025555')).toBeNull()
+		expect(personalCodeToBirthday('39913035552')).toBeNull()
 	})
 
 	test('Latvia', () => {
@@ -56,6 +68,7 @@ describe('invalid personal code', () => {
 		expect(personalCodeToBirthday('999999A123T')).toBeNull()
 		expect(personalCodeToBirthday('131052Z3087')).toBeNull()
 		expect(personalCodeToBirthday('321052A3087')).toBeNull()
+		expect(personalCodeToBirthday('910100A123F')).toBeNull()
 	})
 
 	test('Sweden', () => {
@@ -69,11 +82,19 @@ describe('invalid personal code', () => {
 	})
 
 	test('Denmark', () => {
-		expect(personalCodeToBirthday('9999991234')).toBeNull()
+		expect(personalCodeToBirthday('999999-1234')).toBeNull()
+	})
+
+	test('Ukraine', () => {
+		expect(personalCodeToBirthday('3406105373')).toBeNull()
+	})
+
+	test('Poland', () => {
+		expect(personalCodeToBirthday('24231012343')).toBeNull()
+		expect(personalCodeToBirthday('24234012341')).toBeNull()
 	})
 
-	test('unsupported personal code format', () => {
-		const result = personalCodeToBirthday('abcd1234')
-		expect(result).toBeNull()
+	test('unidentified personal code format', () => {
+		expect(personalCodeToBirthday('abcd1234')).toBeNull()
 	})
 })

package/src/index.ts

@@ -0,0 +1,27 @@
+import denmarkParser from './parsers/denmark'
+import estoniaLithuaniaParser from './parsers/estoniaLithuania'
+import finlandParser from './parsers/finland'
+import latviaParser from './parsers/latvia'
+import norwayParser from './parsers/norway'
+import polandParser from './parsers/poland'
+import swedenParser from './parsers/sweden'
+import ukraineParser from './parsers/ukraine'
+import { ParsedDate } from './types'
+
+export default function personalCodeToBirthday(code: string): ParsedDate | null {
+	if (/^\d{10}$/.test(code)) {
+		return ukraineParser(code)
+	} else if (/^\d{11}$/.test(code)) {
+		return estoniaLithuaniaParser(code) || polandParser(code) || norwayParser(code)
+	} else if (/^\d{12}$/.test(code)) {
+		return swedenParser(code)
+	} else if (/^\d{6}-\d{5}$/.test(code)) {
+		return latviaParser(code)
+	} else if (/^\d{6}[+-A]\d{3}[A-Za-z]$/.test(code)) {
+		return finlandParser(code)
+	} else if (/^\d{6}[+-A]\d{4}$/.test(code)) {
+		return finlandParser(code) || denmarkParser(code)
+	}
+
+	return null
+}

package/src/parsers/denmark.ts

@@ -0,0 +1,30 @@
+import { ParsedDate } from '../types'
+import { isValidDate } from '../utils'
+
+export default function denmarkParser(code: string): ParsedDate | null {
+	if (code.includes('-')) {
+		code = code.replace('-', '')
+	}
+
+	const day = parseInt(code.slice(0, 2), 10)
+	const month = parseInt(code.slice(2, 4), 10)
+	let year = parseInt(code.slice(4, 6), 10)
+	const centuryIndicator = parseInt(code.slice(6, 7), 10)
+
+	// Determine century based on the 7th digit and the year
+	if (centuryIndicator >= 0 && centuryIndicator <= 3) {
+		year += 1900
+	} else if (centuryIndicator >= 4 && centuryIndicator <= 9) {
+		if (year >= 0 && year <= 36) {
+			year += 2000
+		} else {
+			year += 1900
+		}
+	}
+
+	if (!isValidDate(day, month, year)) {
+		return null
+	}
+
+	return { day, month, year }
+}

package/src/parsers/estoniaLithuania.ts

@@ -0,0 +1,52 @@
+import { ParsedDate } from '../types'
+import { isValidDate } from '../utils'
+
+export default function estoniaLithuaniaParser(code: string): ParsedDate | null {
+	if (!isValidChecksum(code)) {
+		return null
+	}
+
+	const centuryCode = parseInt(code[0], 10)
+	const day = parseInt(code.slice(5, 7), 10)
+	const month = parseInt(code.slice(3, 5), 10)
+	let year = parseInt(code.slice(1, 3), 10)
+
+	if (centuryCode === 3 || centuryCode === 4) {
+		year += 1900
+	}
+	if (centuryCode === 5 || centuryCode === 6) {
+		year += 2000
+	}
+
+	if (!isValidDate(day, month, year)) {
+		return null
+	}
+
+	return { day, month, year }
+}
+
+function isValidChecksum(code: string): boolean {
+	const weights1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 1]
+	const weights2 = [3, 4, 5, 6, 7, 8, 9, 1, 2, 3]
+	let checksum = 0
+	let total = 0
+
+	for (let i = 0; i < 10; ++i) {
+		total += Number(code.charAt(i)) * weights1[i]
+	}
+	checksum = total % 11
+
+	total = 0
+	if (checksum === 10) {
+		for (let i = 0; i < 10; ++i) {
+			total += Number(code.charAt(i)) * weights2[i]
+		}
+		checksum = total % 11
+
+		if (10 === checksum) {
+			checksum = 0
+		}
+	}
+
+	return checksum === Number(code[10])
+}

package/src/parsers/finland.ts

@@ -0,0 +1,43 @@
+import { ParsedDate } from '../types'
+import { isValidDate } from '../utils'
+
+export default function finlandParser(code: string): ParsedDate | null {
+	if (!isValidChecksum(code)) {
+		return null
+	}
+
+	const day = parseInt(code.slice(0, 2), 10)
+	const month = parseInt(code.slice(2, 4), 10)
+	const yearSuffix = parseInt(code.slice(4, 6), 10)
+	const centuryMarker = code[6]
+
+	let year = yearSuffix
+
+	// Handle the century based on the marker
+	if (centuryMarker === '+') {
+		year += 1800
+	} else if (centuryMarker === '-') {
+		year += 1900
+	} else if (centuryMarker === 'A') {
+		year += 2000
+	}
+
+	// Validate the parsed date
+	if (!isValidDate(day, month, year)) {
+		return null
+	}
+
+	return { day, month, year }
+}
+
+function isValidChecksum(code: string): boolean {
+	const validChars = '0123456789ABCDEFHJKLMNPRSTUVWXY'
+
+	const serial = code.slice(0, 6) + code.slice(7, 10)
+	const checksum = code[10]
+	const num = parseInt(serial, 10)
+	const remainder = num % 31
+	const expectedChecksum = validChars.charAt(remainder)
+
+	return expectedChecksum === checksum.toUpperCase()
+}

package/src/parsers/latvia.ts

@@ -0,0 +1,24 @@
+import { ParsedDate } from '../types'
+import { isValidDate } from '../utils'
+
+// Correct old school format is DDMMYY-CXXXX
+export default function latviaParser(code: string): ParsedDate | null {
+	const day = parseInt(code.slice(0, 2), 10)
+	const month = parseInt(code.slice(2, 4), 10)
+	let year = parseInt(code.slice(4, 6), 10)
+	const centuryCode = parseInt(code[7], 10)
+
+	// Latvian codes are always from the 20th century, so add 1900
+	if (centuryCode === 2) {
+		year += 2000
+	} else {
+		year += 1900
+	}
+
+	// Validate the parsed date
+	if (!isValidDate(day, month, year)) {
+		return null
+	}
+
+	return { day, month, year }
+}

package/src/parsers/norway.ts

@@ -0,0 +1,24 @@
+import { ParsedDate } from '../types'
+import { isValidDate } from '../utils'
+
+export default function norwayParser(code: string): ParsedDate | null {
+	const day = parseInt(code.slice(0, 2), 10)
+	const month = parseInt(code.slice(2, 4), 10)
+	let year = parseInt(code.slice(4, 6), 10)
+
+	const individual = parseInt(code.slice(6, 9), 10)
+
+	// Determine century based on individual number and year
+	if (individual <= 499 || (individual >= 500 && year >= 40)) {
+		year += 1900
+	} else if (individual <= 999 && year <= 39) {
+		year += 2000
+	}
+
+	// Now validate the date after adjusting the century
+	if (!isValidDate(day, month, year)) {
+		return null
+	}
+
+	return { day, month, year }
+}

package/src/parsers/poland.ts

@@ -0,0 +1,37 @@
+import { ParsedDate } from '../types'
+import { isValidDate } from '../utils'
+
+export default function polandParser(code: string): ParsedDate | null {
+	if (!isValidChecksum(code)) {
+		return null
+	}
+
+	const day = parseInt(code.slice(4, 6), 10)
+	let month = parseInt(code.slice(2, 4), 10)
+	let year = parseInt(code.slice(0, 2), 10)
+
+	// Determine the century based on the month encoding
+	if (month >= 1 && month <= 12) {
+		year += 1900
+	} else if (month >= 21 && month <= 32) {
+		year += 2000
+		month -= 20
+	}
+
+	if (!isValidDate(day, month, year)) {
+		return null
+	}
+
+	return { day, month, year }
+}
+
+function isValidChecksum(code: string): boolean {
+	const weights = [1, 3, 7, 9, 1, 3, 7, 9, 1, 3]
+	const digits = code.slice(0, 10).split('').map(Number)
+
+	const sum = digits.reduce((acc, digit, index) => acc + digit * weights[index], 0)
+
+	const expectedChecksum = (10 - (sum % 10)) % 10
+
+	return expectedChecksum === parseInt(code[10], 10)
+}

package/src/parsers/sweden.ts

@@ -0,0 +1,14 @@
+import { ParsedDate } from '../types'
+import { isValidDate } from '../utils'
+
+export default function swedenParser(code: string): ParsedDate | null {
+	const year = parseInt(code.slice(0, 4), 10)
+	const month = parseInt(code.slice(4, 6), 10)
+	const day = parseInt(code.slice(6, 8), 10)
+
+	if (!isValidDate(day, month, year)) {
+		return null
+	}
+
+	return { day, month, year }
+}

package/src/parsers/ukraine.ts

@@ -0,0 +1,35 @@
+import { ParsedDate } from '../types'
+
+export default function ukrainianParser(code: string): ParsedDate | null {
+	if (!isValidChecksum(code)) {
+		return null
+	}
+
+	// The first 5 digits represent the number of days since 31-12-1899
+	const daysSinceBaseDate = parseInt(code.slice(0, 5), 10)
+	const baseDate = new Date(1899, 11, 31) // Dec 31, 1899
+
+	// Calculate the birthdate from the number of days since the base date
+	const birthDate = new Date(baseDate.getTime() + daysSinceBaseDate * 24 * 60 * 60 * 1000)
+
+	const day = birthDate.getDate()
+	const month = birthDate.getMonth() + 1 // getMonth is zero-based
+	const year = birthDate.getFullYear()
+
+	return { day, month, year }
+}
+
+function isValidChecksum(code: string): boolean {
+	const digits = code.slice(0, 9).split('').map(Number)
+
+	const weights = [-1, 5, 7, 9, 4, 6, 10, 5, 7]
+	const controlSum = digits.reduce((sum, digit, index) => sum + digit * weights[index], 0)
+
+	let controlNumber = controlSum % 11
+
+	if (controlNumber === 10) {
+		controlNumber = 0
+	}
+
+	return controlNumber === parseInt(code[9], 10)
+}

package/src/types.ts

@@ -0,0 +1,5 @@
+export interface ParsedDate {
+	day: number
+	month: number
+	year: number
+}

package/src/utils.ts

@@ -0,0 +1,5 @@
+export function isValidDate(day: number, month: number, year: number): boolean {
+	const date = new Date(year, month - 1, day) // month is zero-indexed in JS Date
+
+	return date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day
+}

package/tsconfig.json

@@ -3,7 +3,7 @@
 	"compilerOptions": {
 		"target": "ES2022",
 		"module": "NodeNext",
-		"rootDir": "./",
+		"rootDir": "./src",
 		"moduleResolution": "NodeNext",
 		"baseUrl": "./",
 		"sourceMap": true,

package/index.ts

@@ -1,192 +0,0 @@
-interface ParsedDate {
-	day: number
-	month: number
-	year: number
-}
-
-export default function personalCodeToBirthday(code: string): ParsedDate | null {
-	if (/^\d{11}$/.test(code)) {
-		// Could be Estonia, Lithuania, or Norway
-		const birthday = estonianLithuanianParser(code)
-		if (birthday) {
-			return birthday
-		}
-
-		return norwayParser(code)
-	} else if (/^\d{6}-\d{5}$/.test(code)) {
-		return latvianParser(code)
-	} else if (/^\d{6}[+-A]\d{3}[A-Za-z]$/.test(code)) {
-		return finlandParser(code)
-	} else if (/^\d{6}[+-A]\d{4}$/.test(code)) {
-		// Could be Finland or Denmark
-		const birthday = finlandParser(code)
-		if (birthday) {
-			return birthday
-		}
-
-		return denmarkParser(code)
-	} else if (/^\d{12}$/.test(code)) {
-		return swedenParser(code)
-	} else if (/^\d{10}$/.test(code)) {
-		return denmarkParser(code)
-	}
-
-	return null
-}
-
-// Estonia (EE) and Lithuanian (LT) Parser
-function estonianLithuanianParser(code: string): ParsedDate | null {
-	const centuryCode = parseInt(code[0], 10)
-	const day = parseInt(code.slice(5, 7), 10)
-	const month = parseInt(code.slice(3, 5), 10)
-	let year = parseInt(code.slice(1, 3), 10)
-
-	if (centuryCode === 3 || centuryCode === 4) {
-		year += 1900
-	}
-	if (centuryCode === 5 || centuryCode === 6) {
-		year += 2000
-	}
-
-	if (!isValidDate(day, month, year)) {
-		return null
-	}
-
-	return { day, month, year }
-}
-
-// Latvia (LV) Parser
-// Correct old school format is DDMMYY-CXXXX
-function latvianParser(code: string): ParsedDate | null {
-	const day = parseInt(code.slice(0, 2), 10)
-	const month = parseInt(code.slice(2, 4), 10)
-	let year = parseInt(code.slice(4, 6), 10)
-	const centuryCode = parseInt(code[7], 10)
-
-	// Latvian codes are always from the 20th century, so add 1900
-	if (centuryCode === 2) {
-		year += 2000
-	} else {
-		year += 1900
-	}
-
-	// Validate the parsed date
-	if (!isValidDate(day, month, year)) {
-		return null
-	}
-
-	return { day, month, year }
-}
-
-// Finland (FI) Parser
-function finlandParser(code: string): ParsedDate | null {
-	const day = parseInt(code.slice(0, 2), 10)
-	const month = parseInt(code.slice(2, 4), 10)
-	const yearSuffix = parseInt(code.slice(4, 6), 10)
-	const centuryMarker = code[6]
-
-	let year = yearSuffix
-
-	// Handle the century based on the marker
-	if (centuryMarker === '+') {
-		year += 1800
-	} else if (centuryMarker === '-') {
-		year += 1900
-	} else if (centuryMarker === 'A') {
-		year += 2000
-	}
-
-	// Validate the parsed date
-	if (!isValidDate(day, month, year)) {
-		return null
-	}
-
-	if (!isValidFinnishChecksum(code)) {
-		return null
-	}
-
-	return { day, month, year }
-}
-
-function isValidFinnishChecksum(code: string): boolean {
-	const validChars = '0123456789ABCDEFHJKLMNPRSTUVWXY'
-
-	const serial = code.slice(0, 6) + code.slice(7, 10)
-	const checksum = code[10]
-	const num = parseInt(serial, 10)
-	const remainder = num % 31
-	const expectedChecksum = validChars.charAt(remainder)
-
-	return expectedChecksum === checksum.toUpperCase()
-}
-
-// Sweden (SE) Parser
-function swedenParser(code: string): ParsedDate | null {
-	const year = parseInt(code.slice(0, 4), 10)
-	const month = parseInt(code.slice(4, 6), 10)
-	const day = parseInt(code.slice(6, 8), 10)
-
-	if (!isValidDate(day, month, year)) {
-		return null
-	}
-
-	return { day, month, year }
-}
-
-// Norway (NO) Parser
-function norwayParser(code: string): ParsedDate | null {
-	const day = parseInt(code.slice(0, 2), 10)
-	const month = parseInt(code.slice(2, 4), 10)
-	let year = parseInt(code.slice(4, 6), 10)
-
-	const individual = parseInt(code.slice(6, 9), 10)
-
-	// Determine century based on individual number and year
-	if (individual <= 499 || (individual >= 500 && year >= 40)) {
-		year += 1900
-	} else if (individual <= 999 && year <= 39) {
-		year += 2000
-	}
-
-	// Now validate the date after adjusting the century
-	if (!isValidDate(day, month, year)) {
-		return null
-	}
-
-	return { day, month, year }
-}
-
-// Denmark (DK) Parser
-function denmarkParser(code: string): ParsedDate | null {
-	if (code.includes('-')) {
-		code = code.replace('-', '')
-	}
-
-	const day = parseInt(code.slice(0, 2), 10)
-	const month = parseInt(code.slice(2, 4), 10)
-	let year = parseInt(code.slice(4, 6), 10)
-	const centuryIndicator = parseInt(code.slice(6, 7), 10)
-
-	// Determine century based on the 7th digit and the year
-	if (centuryIndicator >= 0 && centuryIndicator <= 3) {
-		year += 1900
-	} else if (centuryIndicator >= 4 && centuryIndicator <= 9) {
-		if (year >= 0 && year <= 36) {
-			year += 2000
-		} else {
-			year += 1900
-		}
-	}
-
-	if (!isValidDate(day, month, year)) {
-		return null
-	}
-
-	return { day, month, year }
-}
-
-function isValidDate(day: number, month: number, year: number): boolean {
-	const date = new Date(year, month - 1, day) // month is zero-indexed in JS Date
-
-	return date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day
-}