From 6cea76899f54f7ec89d53a2a5f3a899b8af41d59 Mon Sep 17 00:00:00 2001 From: Bobban Rydh Date: Fri, 23 Oct 2026 00:13:49 +0200 Subject: [PATCH] Namngenerator med svensk namnstatistik MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Ny sida Namngenerator och knappar i karaktärsformuläret som slumpar namn - Namn viktas efter födelseår från SCB (1922-2020) och Skatteverket (2021-), efternamn från SCB; hämtas vid behov och cachas i tabellen NameStat - Födelseår läses från Födelsedatum/Ålder i formuläret - Inbyggd namnlista som reserv, API-route /api/names - Migration 0004_name_stats, README och översättningar Co-Authored-By: Claude Sonnet 5.5 --- README.md | 17 ++ .../migrations/0004_name_stats/migration.sql | 11 ++ prisma/schema.prisma | 11 ++ src/app/api/names/route.ts | 29 +++ src/app/books/[bookId]/e/[kind]/new/page.tsx | 10 +- src/app/books/[bookId]/names/page.tsx | 22 +++ src/components/entity-form.tsx | 17 +- src/components/name-fill.tsx | 52 ++++++ src/components/name-generator.tsx | 176 ++++++++++++++++++ src/components/shell.tsx | 4 + src/i18n/en.ts | 34 ++++ src/i18n/sv.ts | 34 ++++ src/lib/name-client.ts | 66 +++++++ src/lib/name-stats.ts | 158 ++++++++++++++++ src/lib/names.ts | 103 ++++++++++ 15 files changed, 741 insertions(+), 3 deletions(-) create mode 100644 prisma/migrations/0004_name_stats/migration.sql create mode 100644 src/app/api/names/route.ts create mode 100644 src/app/books/[bookId]/names/page.tsx create mode 100644 src/components/name-fill.tsx create mode 100644 src/components/name-generator.tsx create mode 100644 src/lib/name-client.ts create mode 100644 src/lib/name-stats.ts create mode 100644 src/lib/names.ts diff --git a/README.md b/README.md index e4c6e38..22855b3 100644 --- a/README.md +++ b/README.md @@ -100,6 +100,23 @@ Alla ID skapas automatiskt enligt ID-översikten, med löpande nummer per bok oc Appar och Hemsidor har inget ID. Prefixen ligger samlade i `src/lib/ids.ts`. Sidan **ID-register** listar alla ID i boken med sökning och filter. Befintliga poster får ID vid uppgraderingen i den ordning de skapades, och tidigare handskrivna koder ersätts. +## Namngenerator + +Under *Planering → Namngenerator* slumpas svenska namn fram. Välj kvinna, man eller slumpa, **födelseår**, efternamnstyp (alla, bara -son eller utan -son), antal förslag och om ett mellannamn ska ingå. Kopiera ett namn eller klicka *Skapa karaktär* för att starta ett formulär med namnet ifyllt. + +I karaktärsformuläret finns knapparna *Kvinna* och *Man* som slumpar ett namn direkt i namnfältet. De läser födelseår från fälten *Födelsedatum* eller *Ålder* om de är ifyllda, annars slumpas ett år så att åldrarna blir blandade. + +Namnen viktas efter hur vanliga de var, så en man född 1960 blir oftare Anders, Mikael eller Lars och en tjej född 2005 oftare Emma eller Julia. Statistiken är öppna data som hämtas första gången den behövs och sparas i databasen (tabellen `NameStat`), så varje år hämtas bara en gång: + +| Födelseår | Källa | +|---|---| +| 1922–1997 | SCB, tilltalsnamn bland folkbokförda (de 200 vanligaste namnen) | +| 1998–2020 | SCB, nyfödda efter tilltalsnamn och namngivningsår | +| 2021 och senare | Skatteverket, öppna data *Namn på nyfödda* | +| Efternamn | SCB, efternamn med minst 10 bärare (2020), de 100, 1 000 eller 5 000 vanligaste | + +Året flyttas till närmaste år med statistik (tidigast 1922). Servern behöver nå `api.scb.se` och `skatteverket.entryscape.net`. Går det inte används den inbyggda namnlistan i `src/lib/names.ts` (cirka 150 förnamn per kön och 160 efternamn) och sidan visar en varning. Du kan också stänga av statistiken med reglaget *Använd namnstatistik*. + ## Kartor - **Riktig karta**: sök adress, klicka där markeringen ska sitta, koppla den till en bostad, lokal eller plats. Dra för att flytta. *Spara vy* minns utsnittet. diff --git a/prisma/migrations/0004_name_stats/migration.sql b/prisma/migrations/0004_name_stats/migration.sql new file mode 100644 index 0000000..ea75094 --- /dev/null +++ b/prisma/migrations/0004_name_stats/migration.sql @@ -0,0 +1,11 @@ +-- CreateTable +CREATE TABLE "NameStat" ( + "kind" TEXT NOT NULL, + "year" INTEGER NOT NULL, + "source" TEXT NOT NULL, + "entries" JSONB NOT NULL, + "fetchedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + + CONSTRAINT "NameStat_pkey" PRIMARY KEY ("kind","year") +); + diff --git a/prisma/schema.prisma b/prisma/schema.prisma index 1dbc050..f5045ac 100644 --- a/prisma/schema.prisma +++ b/prisma/schema.prisma @@ -218,3 +218,14 @@ model IdCounter { @@id([bookId, key]) } + +// Cache för namnstatistik från SCB och Skatteverket. entries = [[namn, antal], ...] sorterat på antal. +model NameStat { + kind String // "given-female", "given-male" eller "surname" + year Int // födelseår, 0 för efternamn + source String + entries Json + fetchedAt DateTime @default(now()) + + @@id([kind, year]) +} diff --git a/src/app/api/names/route.ts b/src/app/api/names/route.ts new file mode 100644 index 0000000..64dc288 --- /dev/null +++ b/src/app/api/names/route.ts @@ -0,0 +1,29 @@ +import { auth } from "@/auth"; +import { getGivenNames, getSurnames } from "@/lib/name-stats"; + +export const dynamic = "force-dynamic"; + +// GET /api/names?type=given&sex=female&year=1985 eller /api/names?type=surnames&limit=1000 +export async function GET(req: Request) { + const session = await auth(); + if (!session?.user) return new Response("Unauthorized", { status: 401 }); + + const url = new URL(req.url); + const type = url.searchParams.get("type"); + try { + if (type === "given") { + const sex = url.searchParams.get("sex"); + const year = Number(url.searchParams.get("year")); + if ((sex !== "female" && sex !== "male") || !Number.isFinite(year)) return Response.json({ error: "Invalid parameters" }, { status: 400 }); + return Response.json(await getGivenNames(sex, year), { headers: { "Cache-Control": "private, max-age=3600" } }); + } + if (type === "surnames") { + const limit = Number(url.searchParams.get("limit") ?? 1000); + return Response.json(await getSurnames(Number.isFinite(limit) ? limit : 1000), { headers: { "Cache-Control": "private, max-age=3600" } }); + } + return Response.json({ error: "Invalid type" }, { status: 400 }); + } catch (error) { + // Statistiktjänsten kan vara nere eller servern sakna internet: klienten faller tillbaka på den inbyggda listan + return Response.json({ error: error instanceof Error ? error.message : "Unknown error" }, { status: 502 }); + } +} diff --git a/src/app/books/[bookId]/e/[kind]/new/page.tsx b/src/app/books/[bookId]/e/[kind]/new/page.tsx index 15ee7e7..a29cfce 100644 --- a/src/app/books/[bookId]/e/[kind]/new/page.tsx +++ b/src/app/books/[bookId]/e/[kind]/new/page.tsx @@ -7,8 +7,15 @@ import { KIND_BY_SLUG } from "@/lib/kinds"; import { requireBook } from "@/lib/session"; import { getTemplate } from "@/lib/templates"; -export default async function NewEntityPage({ params }: { params: Promise<{ bookId: string; kind: string }> }) { +export default async function NewEntityPage({ + params, + searchParams, +}: { + params: Promise<{ bookId: string; kind: string }>; + searchParams: Promise<{ name?: string }>; +}) { const { bookId, kind: slug } = await params; + const { name } = await searchParams; await requireBook(bookId); const info = KIND_BY_SLUG.get(slug); if (!info) notFound(); @@ -24,6 +31,7 @@ export default async function NewEntityPage({ params }: { params: Promise<{ book bookId={bookId} kind={info.kind} fields={fields} + defaultName={name?.slice(0, 200)} cancelHref={`/books/${bookId}/e/${slug}`} t={t} /> diff --git a/src/app/books/[bookId]/names/page.tsx b/src/app/books/[bookId]/names/page.tsx new file mode 100644 index 0000000..34d4092 --- /dev/null +++ b/src/app/books/[bookId]/names/page.tsx @@ -0,0 +1,22 @@ +import { NameGenerator } from "@/components/name-generator"; +import { PageBody, PageHeader } from "@/components/page"; +import { getT } from "@/i18n/server"; +import { requireBook } from "@/lib/session"; + +export const metadata = { title: "Namngenerator" }; + +export default async function NamesPage({ params }: { params: Promise<{ bookId: string }> }) { + const { bookId } = await params; + await requireBook(bookId); + const { t } = await getT(); + + return ( + <> + + +

{t("names.intro")}

+ +
+ + ); +} diff --git a/src/components/entity-form.tsx b/src/components/entity-form.tsx index acd6cc1..38bf5ce 100644 --- a/src/components/entity-form.tsx +++ b/src/components/entity-form.tsx @@ -2,6 +2,7 @@ import { Fragment } from "react"; import Link from "next/link"; import type { Entity, EntityKind } from "@prisma/client"; import type { TFunction } from "@/i18n/core"; +import { NameFill } from "./name-fill"; import { fileUrl } from "@/lib/files"; import type { FieldDef } from "@/lib/templates"; @@ -51,6 +52,7 @@ export function EntityForm({ entity, fields, cancelHref, + defaultName, t, }: { action: (formData: FormData) => Promise; @@ -59,6 +61,7 @@ export function EntityForm({ entity?: Entity; fields: FieldDef[]; cancelHref: string; + defaultName?: string; t: TFunction; }) { const data = (entity?.data ?? {}) as Record; @@ -74,8 +77,18 @@ export function EntityForm({
- - +
+ + {kind === "CHARACTER" ? : null} +
+
diff --git a/src/components/name-fill.tsx b/src/components/name-fill.tsx new file mode 100644 index 0000000..805a09f --- /dev/null +++ b/src/components/name-fill.tsx @@ -0,0 +1,52 @@ +"use client"; + +import { useState } from "react"; +import { IconDice5 } from "@tabler/icons-react"; +import { useT } from "@/i18n/client"; +import { loadPools } from "@/lib/name-client"; +import { generateName } from "@/lib/names"; + +/** Födelseår från formulärets födelsedatum eller ålder. Saknas båda slumpas ett år, så att åldrarna blir blandade. */ +function birthYearFromForm(form: HTMLFormElement | null): number { + const date = form?.querySelector('input[name="f_birthDate"]')?.value; + const dateYear = date ? Number(date.slice(0, 4)) : NaN; + if (Number.isFinite(dateYear) && dateYear > 1800) return dateYear; + + const age = Number(form?.querySelector('input[name="f_age"]')?.value); + if (Number.isFinite(age) && age > 0 && age < 120) return new Date().getFullYear() - Math.round(age); + + return 1950 + Math.floor(Math.random() * 58); +} + +/** Knappar i karaktärsformuläret som slumpar fram ett namn och skriver in det i namnfältet. */ +export function NameFill() { + const t = useT(); + const [busy, setBusy] = useState(false); + + async function fill(gender: "female" | "male") { + const input = document.querySelector('form input[name="name"]'); + if (!input) return; + setBusy(true); + try { + const { pools } = await loadPools({ year: birthYearFromForm(input.form), surnameLimit: 1000, genders: [gender] }); + input.value = generateName({ gender, middleName: false, surname: "all" }, pools); + input.dispatchEvent(new Event("input", { bubbles: true })); + input.focus(); + } finally { + setBusy(false); + } + } + + return ( +
+ + +
+ ); +} diff --git a/src/components/name-generator.tsx b/src/components/name-generator.tsx new file mode 100644 index 0000000..286c1ea --- /dev/null +++ b/src/components/name-generator.tsx @@ -0,0 +1,176 @@ +"use client"; + +import { useState } from "react"; +import Link from "next/link"; +import { IconCheck, IconCopy, IconDice5, IconUserPlus } from "@tabler/icons-react"; +import { useT } from "@/i18n/client"; +import { loadPools } from "@/lib/name-client"; +import { BUILT_IN_POOLS, generateNames, type NameOptions, type NamePools } from "@/lib/names"; + +const THIS_YEAR = new Date().getFullYear(); + +export function NameGenerator({ bookId }: { bookId: string }) { + const t = useT(); + const [options, setOptions] = useState({ gender: "any", middleName: false, surname: "all" }); + const [count, setCount] = useState(10); + const [useStats, setUseStats] = useState(true); + const [year, setYear] = useState(1990); + const [surnameLimit, setSurnameLimit] = useState(1000); + const [names, setNames] = useState([]); + const [copied, setCopied] = useState(null); + const [loading, setLoading] = useState(false); + const [info, setInfo] = useState<{ sources: string[]; fellBack: boolean; adjustedYear?: number } | null>(null); + + async function roll() { + setLoading(true); + let pools: NamePools = BUILT_IN_POOLS; + let next: typeof info = null; + if (useStats) { + const genders = options.gender === "any" ? (["female", "male"] as const) : ([options.gender] as const); + const loaded = await loadPools({ year, surnameLimit, genders: [...genders] }); + pools = loaded.pools; + next = { sources: loaded.sources, fellBack: loaded.fellBack, adjustedYear: loaded.adjustedYear }; + } + setInfo(next); + setNames(generateNames(options, count, pools)); + setLoading(false); + } + + async function copy(name: string) { + try { + await navigator.clipboard.writeText(name); + setCopied(name); + setTimeout(() => setCopied(null), 1500); + } catch { + // Urklipp kan vara blockerat, namnet går fortfarande att markera för hand + } + } + + return ( +
+
+
+
+
+ +
+ {(["female", "male", "any"] as const).map((g) => ( + + ))} +
+
+ + + + {useStats ? ( + <> +
+ + setYear(Number(e.target.value) || 1990)} + /> +
{t("names.ageApprox", { age: Math.max(0, THIS_YEAR - year) })}
+
+
+ + +
+ + ) : null} + +
+ + +
+
+ + setCount(Math.min(30, Math.max(1, Number(e.target.value) || 1)))} + /> +
+ +
+
+ +
+
+
+ +
+ {info?.fellBack ?
{t("names.fallback")}
: null} + {info?.adjustedYear ?
{t("names.yearAdjusted", { year: info.adjustedYear })}
: null} +
+ {names.length === 0 ? ( +
{t("names.empty")}
+ ) : ( +
+ {names.map((name) => ( +
+ {name} + + + + {t("names.createCharacter")} + +
+ ))} +
+ )} +
+ {info && info.sources.length > 0 ? ( +
{t("names.source", { sources: info.sources.join(" · ") })}
+ ) : null} +
+
+ ); +} diff --git a/src/components/shell.tsx b/src/components/shell.tsx index f2b9d1f..ef1e6eb 100644 --- a/src/components/shell.tsx +++ b/src/components/shell.tsx @@ -3,6 +3,7 @@ import { IconArrowLeft, IconBook2, IconCalendarWeek, + IconDice5, IconChartDots3, IconLayoutDashboard, IconListDetails, @@ -117,6 +118,9 @@ export async function Shell({ user, book, children }: ShellProps) { }> {t("nav.maps")} + }> + {t("nav.names")} + }> {t("nav.templates")} diff --git a/src/i18n/en.ts b/src/i18n/en.ts index c088d99..b73a5d4 100644 --- a/src/i18n/en.ts +++ b/src/i18n/en.ts @@ -48,6 +48,40 @@ export const en: Record = { "nav.schedules": "Schedules", "nav.maps": "Maps", "nav.templates": "Templates", + "nav.names": "Name generator", + "names.title": "Name generator", + "names.intro": "Generates Swedish names for characters. Enter a year of birth and names are picked by how common they were that year. Copy a name or create a character straight away.", + "names.stats": "Use name statistics", + "names.statsHelp": "Names are weighted by how common they were for people born that year (Statistics Sweden and the Swedish Tax Agency).", + "names.birthYear": "Year of birth", + "names.ageApprox": "About {age} years old today", + "names.breadth": "Surnames to choose from", + "names.breadth.100": "The 100 most common", + "names.breadth.1000": "The 1,000 most common", + "names.breadth.5000": "The 5,000 most common", + "names.loading": "Fetching statistics…", + "names.fallback": "The statistics could not be fetched right now. The built-in name list is used for the missing parts.", + "names.yearAdjusted": "There are no statistics for that year, so names from {year} are used.", + "names.source": "Source: {sources}", + "names.gender": "Gender", + "names.gender.female": "Woman", + "names.gender.male": "Man", + "names.gender.any": "Random", + "names.surname": "Surname", + "names.surname.all": "All surnames", + "names.surname.son": "Only -son names (Andersson ...)", + "names.surname.other": "Without -son (Lindqvist, Berg ...)", + "names.count": "Number of suggestions", + "names.middle": "Add a middle name", + "names.generate": "Generate names", + "names.again": "Generate again", + "names.empty": "Press the button to get name suggestions.", + "names.copy": "Copy", + "names.copied": "Copied", + "names.createCharacter": "Create character", + "names.fill": "Random name", + "names.fillFemale": "Random woman's name", + "names.fillMale": "Random man's name", "nav.settings": "Book settings", "nav.logout": "Log out", "nav.theme": "Toggle theme", diff --git a/src/i18n/sv.ts b/src/i18n/sv.ts index a1d8cd7..ce97ad0 100644 --- a/src/i18n/sv.ts +++ b/src/i18n/sv.ts @@ -46,6 +46,40 @@ export const sv = { "nav.schedules": "Scheman", "nav.maps": "Kartor", "nav.templates": "Mallar", + "nav.names": "Namngenerator", + "names.title": "Namngenerator", + "names.intro": "Slumpar fram svenska namn till karaktärer. Ange födelseår så väljs namn efter hur vanliga de var det året. Kopiera ett namn eller skapa en karaktär direkt.", + "names.stats": "Använd namnstatistik", + "names.statsHelp": "Namnen viktas efter hur vanliga de var för personer födda det året (SCB och Skatteverket).", + "names.birthYear": "Födelseår", + "names.ageApprox": "Ungefär {age} år gammal i dag", + "names.breadth": "Efternamn att välja bland", + "names.breadth.100": "De 100 vanligaste", + "names.breadth.1000": "De 1 000 vanligaste", + "names.breadth.5000": "De 5 000 vanligaste", + "names.loading": "Hämtar statistik…", + "names.fallback": "Statistiken kunde inte hämtas just nu. Den inbyggda namnlistan används för de delar som saknas.", + "names.yearAdjusted": "Statistik saknas för det året, så namn från {year} används.", + "names.source": "Källa: {sources}", + "names.gender": "Kön", + "names.gender.female": "Kvinna", + "names.gender.male": "Man", + "names.gender.any": "Slumpa", + "names.surname": "Efternamn", + "names.surname.all": "Alla efternamn", + "names.surname.son": "Bara -son-namn (Andersson ...)", + "names.surname.other": "Utan -son (Lindqvist, Berg ...)", + "names.count": "Antal förslag", + "names.middle": "Lägg till mellannamn", + "names.generate": "Slumpa fram namn", + "names.again": "Slumpa igen", + "names.empty": "Tryck på knappen för att få namnförslag.", + "names.copy": "Kopiera", + "names.copied": "Kopierat", + "names.createCharacter": "Skapa karaktär", + "names.fill": "Slumpa namn", + "names.fillFemale": "Slumpa ett kvinnonamn", + "names.fillMale": "Slumpa ett mansnamn", "nav.settings": "Bokinställningar", "nav.logout": "Logga ut", "nav.theme": "Växla tema", diff --git a/src/lib/name-client.ts b/src/lib/name-client.ts new file mode 100644 index 0000000..e56e612 --- /dev/null +++ b/src/lib/name-client.ts @@ -0,0 +1,66 @@ +import { BUILT_IN_POOLS, type Entry, type NamePools } from "./names"; + +type GivenResponse = { entries: Entry[]; source: string; year: number; requestedYear: number }; +type SurnameResponse = { entries: Entry[]; source: string }; + +// Svaren cachas i webbläsaren så att samma år inte hämtas flera gånger +const cache = new Map>(); + +function api(query: string): Promise { + let promise = cache.get(query) as Promise | undefined; + if (!promise) { + promise = fetch(`/api/names?${query}`).then(async (res) => { + if (!res.ok) throw new Error(`${res.status}`); + return (await res.json()) as T; + }); + cache.set(query, promise); + promise.catch(() => cache.delete(query)); + } + return promise; +} + +export type LoadedPools = { + pools: NamePools; + /** Källor som användes, t.ex. "SCB, nyfödda 2005". */ + sources: string[]; + /** Sant om statistiken inte gick att hämta och den inbyggda listan användes för någon del. */ + fellBack: boolean; + /** Satt om begärt år flyttades till närmaste år med statistik. */ + adjustedYear?: number; +}; + +/** Hämtar viktade namnlistor för ett födelseår. Delar som inte går att hämta ersätts av den inbyggda listan. */ +export async function loadPools(options: { + year: number; + surnameLimit: number; + genders: ("female" | "male")[]; +}): Promise { + const pools: NamePools = { ...BUILT_IN_POOLS }; + const sources: string[] = []; + let fellBack = false; + let adjustedYear: number | undefined; + + const given = await Promise.allSettled( + options.genders.map((sex) => api(`type=given&sex=${sex}&year=${Math.round(options.year)}`)), + ); + given.forEach((result, i) => { + const sex = options.genders[i]; + if (result.status === "fulfilled" && result.value.entries.length > 0) { + pools[sex] = result.value.entries; + if (!sources.includes(result.value.source)) sources.push(result.value.source); + if (result.value.year !== Math.round(options.year)) adjustedYear = result.value.year; + } else { + fellBack = true; + } + }); + + try { + const surnames = await api(`type=surnames&limit=${options.surnameLimit}`); + pools.surnames = surnames.entries; + sources.push(surnames.source); + } catch { + fellBack = true; + } + + return { pools, sources, fellBack, adjustedYear }; +} diff --git a/src/lib/name-stats.ts b/src/lib/name-stats.ts new file mode 100644 index 0000000..51a8bf5 --- /dev/null +++ b/src/lib/name-stats.ts @@ -0,0 +1,158 @@ +import type { Prisma } from "@prisma/client"; +import { prisma } from "./db"; + +// Namnstatistik från öppna data. Hämtas vid första användning och sparas i databasen (tabellen NameStat). +// - Födda 1922–1997: SCB, "Tilltalsnamn, de 100 vanligaste" per födelseår (antal bärare 31 dec 2021) +// - Födda 1998–2020: SCB, nyfödda efter tilltalsnamn och namngivningsår +// - Födda 2021 och senare: Skatteverkets öppna data "Namn på nyfödda" +// - Efternamn: SCB, efternamn med minst 10 bärare (2020), de vanligaste sparas +// Allt är öppna data utan nyckel. + +export type Entry = [string, number]; +export type Sex = "female" | "male"; + +export const MIN_YEAR = 1922; +const SCB_G = "https://api.scb.se/OV0104/v1/doris/sv/ssd/BE/BE0001/BE0001G"; +const SCB_D = "https://api.scb.se/OV0104/v1/doris/sv/ssd/BE/BE0001/BE0001D"; +const SKATTEVERKET = "https://skatteverket.entryscape.net/rowstore/dataset/da2556d0-c717-45e8-a1d8-3320161d3a7d"; +const SURNAME_YEAR = 2020; +const SURNAME_KEEP = 5000; +const REFRESH_AFTER_MS = 90 * 24 * 60 * 60 * 1000; + +export const maxYear = () => new Date().getFullYear() - 1; + +/** Gör SCB:s versaler (JACOB, MOHAMMAD) till vanlig skrivning och slår ihop dubbletter. */ +function normalize(raw: string): string | null { + const name = raw.trim(); + if (!name || name.length > 30 || /[\d\s]/.test(name) || !/^[\p{L}'-]+$/u.test(name)) return null; + return name + .split("-") + .map((part) => (part.length > 1 && part === part.toUpperCase() ? part[0] + part.slice(1).toLowerCase() : part)) + .join("-"); +} + +function toEntries(counts: Map, keep?: number): Entry[] { + const list = [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0], "sv")); + return (keep ? list.slice(0, keep) : list) as Entry[]; +} + +function add(counts: Map, rawName: string, rawCount: unknown) { + const name = normalize(rawName); + const count = Number(rawCount); + if (!name || !Number.isFinite(count) || count <= 0) return; + counts.set(name, (counts.get(name) ?? 0) + count); +} + +async function scbQuery(url: string, query: { code: string; selection: { filter: string; values: string[] } }[]) { + const res = await fetch(url, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ query, response: { format: "json" } }), + signal: AbortSignal.timeout(60_000), + }); + if (!res.ok) throw new Error(`SCB svarade ${res.status}`); + const body = JSON.parse((await res.text()).replace(/^/, "")) as { data: { key: string[]; values: string[] }[] }; + return body.data; +} + +async function fetchScbOldNames(sex: Sex, year: number): Promise { + const rows = await scbQuery(`${SCB_G}/BE0001T100`, [ + { code: "Tilltalsnamn", selection: { filter: "all", values: ["*"] } }, + { code: "ContentsCode", selection: { filter: "item", values: ["BE0001AN"] } }, + { code: "Tid", selection: { filter: "item", values: [String(year)] } }, + ]); + const prefix = sex === "male" ? "1" : "2"; // SCB lägger 1 (män) eller 2 (kvinnor) framför namnet + const counts = new Map(); + for (const row of rows) if (row.key[0].startsWith(prefix)) add(counts, row.key[0].slice(1), row.values[0]); + return toEntries(counts); +} + +async function fetchScbNewborns(sex: Sex, year: number): Promise { + const rows = await scbQuery(`${SCB_D}/BE0001Nyfodda`, [ + { code: "Tilltalsnamn", selection: { filter: "all", values: ["*"] } }, + { code: "Kon", selection: { filter: "item", values: [sex === "male" ? "1" : "2"] } }, + { code: "ContentsCode", selection: { filter: "item", values: ["000004F5"] } }, + { code: "Tid", selection: { filter: "item", values: [String(year)] } }, + ]); + const counts = new Map(); + for (const row of rows) add(counts, row.key[0], row.values[0]); + return toEntries(counts); +} + +async function fetchSkatteverket(sex: Sex, year: number): Promise { + const counts = new Map(); + const pageSize = 500; + for (let page = 0; page < 6; page++) { + const url = `${SKATTEVERKET}?gruppering=Total&fodelsear=${year}&k%C3%B6n=${sex === "female" ? "Kvinna" : "Man"}&_limit=${pageSize}&_offset=${page * pageSize}`; + const res = await fetch(url, { signal: AbortSignal.timeout(30_000), headers: { Accept: "application/json" } }); + if (!res.ok) throw new Error(`Skatteverket svarade ${res.status}`); + const body = (await res.json()) as { results?: { namn?: string; antal?: string }[] }; + const results = body.results ?? []; + for (const row of results) add(counts, row.namn ?? "", row.antal); + if (results.length < pageSize) break; + } + return toEntries(counts); +} + +function sourceFor(year: number): { label: string; fetch: (sex: Sex, year: number) => Promise } { + if (year >= 2021) return { label: "Skatteverket", fetch: fetchSkatteverket }; + if (year >= 1998) return { label: "SCB", fetch: fetchScbNewborns }; + return { label: "SCB", fetch: fetchScbOldNames }; +} + +export type GivenNames = { entries: Entry[]; source: string; year: number; requestedYear: number }; + +/** Förnamn för personer födda ett visst år, viktade efter antal. År utanför statistiken flyttas till närmaste. */ +export async function getGivenNames(sex: Sex, requestedYear: number): Promise { + let year = Math.min(maxYear(), Math.max(MIN_YEAR, Math.round(requestedYear))); + const kind = `given-${sex}`; + + for (let attempt = 0; attempt < 3; attempt++, year--) { + const cached = await prisma.nameStat.findUnique({ where: { kind_year: { kind, year } } }); + const fresh = cached && (year < 2021 || Date.now() - cached.fetchedAt.getTime() < REFRESH_AFTER_MS); + if (cached && fresh) return { entries: cached.entries as Entry[], source: cached.source, year, requestedYear }; + + const source = sourceFor(year); + const entries = await source.fetch(sex, year); + // Nytt år kan saknas i Skatteverkets data tills det publicerats: pröva året före + if (entries.length === 0) { + if (cached) return { entries: cached.entries as Entry[], source: cached.source, year, requestedYear }; + continue; + } + const sourceText = `${source.label}, ${year >= 1998 ? "nyfödda" : "födda"} ${year}`; + await prisma.nameStat.upsert({ + where: { kind_year: { kind, year } }, + create: { kind, year, source: sourceText, entries: entries as unknown as Prisma.InputJsonArray }, + update: { source: sourceText, entries: entries as unknown as Prisma.InputJsonArray, fetchedAt: new Date() }, + }); + return { entries, source: sourceText, year, requestedYear }; + } + throw new Error("Ingen namnstatistik hittades för året"); +} + +export type Surnames = { entries: Entry[]; source: string }; + +/** De vanligaste efternamnen med antal bärare. `limit` kortar listan till de vanligaste. */ +export async function getSurnames(limit: number): Promise { + const kind = "surname"; + let row = await prisma.nameStat.findUnique({ where: { kind_year: { kind, year: 0 } } }); + if (!row) { + const rows = await scbQuery(`${SCB_G}/BE0001ENamn10`, [ + { code: "Efternamn", selection: { filter: "all", values: ["*"] } }, + { code: "ContentsCode", selection: { filter: "item", values: ["BE0001AK"] } }, + { code: "Tid", selection: { filter: "item", values: [String(SURNAME_YEAR)] } }, + ]); + const counts = new Map(); + for (const r of rows) add(counts, r.key[0], r.values[0]); + const entries = toEntries(counts, SURNAME_KEEP); + if (entries.length === 0) throw new Error("SCB gav inga efternamn"); + const source = `SCB, efternamn ${SURNAME_YEAR}`; + row = await prisma.nameStat.upsert({ + where: { kind_year: { kind, year: 0 } }, + create: { kind, year: 0, source, entries: entries as unknown as Prisma.InputJsonArray }, + update: { source, entries: entries as unknown as Prisma.InputJsonArray, fetchedAt: new Date() }, + }); + } + const size = Math.min(SURNAME_KEEP, Math.max(10, Math.round(limit))); + return { entries: (row.entries as Entry[]).slice(0, size), source: row.source }; +} diff --git a/src/lib/names.ts b/src/lib/names.ts new file mode 100644 index 0000000..4fdb1eb --- /dev/null +++ b/src/lib/names.ts @@ -0,0 +1,103 @@ +// Svenska namn till namngeneratorn. Listorna är fria att utöka. + +const split = (s: string) => [...new Set(s.split(",").map((n) => n.trim()).filter(Boolean))]; + +export const FEMALE_NAMES = split(` +Maria, Anna, Margareta, Elisabeth, Eva, Birgitta, Kristina, Karin, Marie, Ingrid, Sofia, Emma, Linnea, Elin, +Hanna, Johanna, Sara, Lena, Annika, Camilla, Malin, Josefin, Frida, Ida, Julia, Amanda, Emelie, Matilda, Ebba, +Alice, Wilma, Maja, Ella, Olivia, Alma, Astrid, Saga, Agnes, Vera, Klara, Freja, Lovisa, Lisa, Helena, Cecilia, +Jenny, Susanne, Monica, Gunilla, Carina, Pernilla, Charlotte, Therese, Madeleine, Sandra, Jessica, Lina, Ellen, +Moa, Tilda, Nora, Stina, Siri, Tove, Ylva, Åsa, Maud, Gerd, Lotta, Mia, Nina, Petra, Rebecka, Sanna, Thea, +Viktoria, Isabella, Ronja, Selma, Elsa, Signe, Greta, Hedvig, Disa, Tora, Alva, Livia, Elvira, Linda, Anette, +Ulrika, Veronica, Gunnel, Barbro, Kerstin, Britt, Marianne, Inger, Lilian, Ann-Christin, Ann-Marie, Anne-Lie, +Katarina, Louise, Emilia, Caroline, Jennie, Paulina, Mathilda, Julia, Felicia, Isabelle, Nathalie, Beatrice, +Cornelia, Elsie, Märta, Ingegerd, Solveig, Siv, Berit, Gun, Ulla, Yvonne, Margit, Doris, Rut, Brita, Ewa, +Mona, Lisbeth, Gudrun, Hillevi, Maj-Britt, Ragnhild, Sigrid, Tyra, Lilly, Stella, Melina, Leah, Nellie, Tuva, +Mira, Ester, Edith, Ellie, Iris, Vanessa, Johanna, Therese, Tiina, Pia, Helene, Sofie, Cajsa, Sussi +`); + +export const MALE_NAMES = split(` +Lars, Anders, Johan, Erik, Per, Karl, Peter, Mikael, Jan, Thomas, Daniel, Fredrik, Andreas, Magnus, Mats, Stefan, +Marcus, Mattias, Björn, Jonas, Henrik, Martin, Patrik, Niklas, Oskar, William, Lucas, Liam, Hugo, Oliver, Elias, +Noah, Axel, Alexander, Viktor, Filip, Emil, Gustav, Albin, Adam, Theodor, Leo, Isak, Sebastian, Simon, Linus, +Ludvig, Rasmus, Jesper, Joakim, Christian, Robert, Bengt, Göran, Hans, Ulf, Sven, Gunnar, Bo, Nils, Olof, Ingvar, +Roland, Kjell, Leif, Tommy, Håkan, Kenneth, Roger, Stig, Lennart, Rolf, Tobias, David, Jonathan, Samuel, +Benjamin, Melvin, Vincent, Edvin, Ville, Malte, Folke, Arvid, Elof, Sixten, Sigge, Valter, Wilmer, Theo, Kalle, +Pontus, Dennis, Mohammed, Carl, Johannes, Christoffer, Jimmy, Joel, Gabriel, Max, Ivar, Otto, Ture, Harry, +Alfred, Einar, Gösta, Rune, Torsten, Evert, Allan, Ove, Tore, Ragnar, Åke, Sture, Gert, Bertil, Curt, Dan, +Mikael, Kristoffer, Fabian, Anton, Jacob, Erland, August, Olle, Love, Melker, Kasper, Hampus, Isidor, Leopold, +Ebbe, Eskil, Sten, Valdemar, Elmer, Morgan, Lasse, Kurt, Jörgen, Claes, Staffan, Ola, Pär, Oscar, Tim, Jens +`); + +export const SURNAMES = split(` +Andersson, Johansson, Karlsson, Nilsson, Eriksson, Larsson, Olsson, Persson, Svensson, Gustafsson, Pettersson, +Jonsson, Jansson, Hansson, Bengtsson, Jönsson, Lindberg, Jakobsson, Magnusson, Olofsson, Lindström, Lindqvist, +Lindgren, Axelsson, Berg, Bergström, Lundberg, Lind, Lundgren, Lundqvist, Mattsson, Berglund, Fredriksson, +Sandberg, Henriksson, Forsberg, Sjöberg, Wallin, Engström, Eklund, Danielsson, Håkansson, Lundin, Björk, +Bergman, Gunnarsson, Holm, Wikström, Samuelsson, Isaksson, Fransson, Bergqvist, Nyström, Holmberg, Arvidsson, +Löfgren, Söderberg, Nyberg, Blomqvist, Claesson, Nordström, Mårtensson, Lundström, Eliasson, Pålsson, +Björklund, Berggren, Sandström, Lund, Nordin, Ström, Åberg, Hermansson, Ekström, Holmgren, Hedlund, Dahlberg, +Hellström, Sjögren, Abrahamsson, Martinsson, Öberg, Andreasson, Strömberg, Månsson, Åkesson, Blom, Falk, +Sundström, Hägglund, Norberg, Ek, Lindholm, Dahl, Forsman, Ahlström, Sköld, Wiklund, Lindahl, Engman, Ljung, +Palm, Rydberg, Vikström, Stenberg, Backman, Nordlund, Hedström, Sundberg, Lindén, Wass, Strand, Edlund, +Backlund, Roos, Bäckström, Åström, Rosén, Sjölund, Landin, Tjäder, Franzén, Lövgren, Linder, Thorén, Ericsson, +Nygren, Westerberg, Alm, Sjöstrand, Ohlsson, Holmqvist, Näslund, Wahlström, Gran, Hagberg, Hjort, Lilja, +Fors, Strid, Qvist, Dalén, Hallberg, Kjellberg, Frisk, Skog, Söderström, Ahlgren, Brandt, Eng, Enström, +Winberg, Zetterberg, Åhlén, Hammar, Öhman, Ragnarsson, Sundqvist, Wester, Stålhammar, Silfverberg, Kronberg +`); + +export type Entry = [string, number]; + +/** Namn med vikt (hur vanliga de är). Den inbyggda listan har samma vikt för alla namn. */ +export type NamePools = { female: Entry[]; male: Entry[]; surnames: Entry[] }; + +const flat = (names: string[]): Entry[] => names.map((n) => [n, 1]); + +export const BUILT_IN_POOLS: NamePools = { + female: flat(FEMALE_NAMES), + male: flat(MALE_NAMES), + surnames: flat(SURNAMES), +}; + +export type NameOptions = { + gender: "female" | "male" | "any"; + middleName: boolean; + surname: "all" | "son" | "other"; +}; + +function pickWeighted(entries: Entry[], rand: () => number): string { + const total = entries.reduce((sum, [, weight]) => sum + weight, 0); + let roll = rand() * total; + for (const [name, weight] of entries) { + roll -= weight; + if (roll < 0) return name; + } + return entries[entries.length - 1][0]; +} + +export function generateName(options: NameOptions, pools: NamePools = BUILT_IN_POOLS, rand: () => number = Math.random): string { + const female = options.gender === "female" || (options.gender === "any" && rand() < 0.5); + const given = female ? pools.female : pools.male; + const first = pickWeighted(given, rand); + + let middle = ""; + if (options.middleName) { + const second = pickWeighted(given, rand); + if (second !== first) middle = ` ${second}`; + } + + const surnames = + options.surname === "son" + ? pools.surnames.filter(([s]) => s.endsWith("son")) + : options.surname === "other" + ? pools.surnames.filter(([s]) => !s.endsWith("son")) + : pools.surnames; + + return `${first}${middle} ${pickWeighted(surnames.length ? surnames : pools.surnames, rand)}`; +} + +export function generateNames(options: NameOptions, count: number, pools: NamePools = BUILT_IN_POOLS): string[] { + const names = new Set(); + for (let i = 0; i < count * 5 && names.size < count; i++) names.add(generateName(options, pools)); + return [...names]; +}