svelte-kit-vice/scripts/generate-emoji-data.ts

/**
 * Bake the vendored emojibase snapshot into a compact, statically-imported
 * TS module for `$libs/emoji`. Mirrors the lucide-icon precedent
 * (`scripts/generate-icon-categories.js`): a third-party dataset lives raw in
 * `static/` and a generator prunes it into a baked module — no runtime dep.
 *
 * Source : static/emoji/compact.json + messages.json (emojibase-data@16, MIT).
 * Output : src/libs/emoji/data.ts  (DO NOT EDIT — regenerate via this script).
 * Run    : npm run generate:emoji-data
 *
 * Pruning: keep pickable emoji only (drop the `component` group — skin-tone /
 * hair modifiers are not pickable glyphs). Per entry we keep the glyph, the
 * CLDR name, the group index, a space-joined keyword string (search), and —
 * for single-person tone-capable emoji — the five Fitzpatrick tone glyphs.
 */
import { readFileSync, writeFileSync } from 'node:fs'
import { fileURLToPath } from 'node:url'
import { dirname, resolve } from 'node:path'

const here = dirname(fileURLToPath(import.meta.url))
const root = resolve(here, '..')

interface CompactSkin {
	hexcode: string
	unicode: string
	label: string
}
interface CompactEmoji {
	hexcode: string
	label: string
	unicode: string
	group?: number
	order?: number
	tags?: string[]
	skins?: CompactSkin[]
}
interface Messages {
	groups: { order: number; key: string; message: string }[]
	skinTones: { key: string; message: string }[]
}

const COMPONENT_GROUP = 2 // skin-tone + hair modifiers — never pickable.

// Fitzpatrick modifiers in light→dark order (the tone-selector order).
const TONE_MODIFIERS = [
	{ slot: 1, key: 'light', mod: '1F3FB' },
	{ slot: 2, key: 'medium-light', mod: '1F3FC' },
	{ slot: 3, key: 'medium', mod: '1F3FD' },
	{ slot: 4, key: 'medium-dark', mod: '1F3FE' },
	{ slot: 5, key: 'dark', mod: '1F3FF' }
] as const

const stripVS = (hex: string) => hex.replace(/-FE0F/g, '')
const isMod = (codepoint: string) => /^1F3F[B-F]$/.test(codepoint)

const compact: CompactEmoji[] = JSON.parse(
	readFileSync(resolve(root, 'static/emoji/compact.json'), 'utf8')
)
const messages: Messages = JSON.parse(
	readFileSync(resolve(root, 'static/emoji/messages.json'), 'utf8')
)

// Groups (excl. component), in canonical order.
const groups = messages.groups
	.filter((g) => g.order !== COMPONENT_GROUP)
	.sort((a, b) => a.order - b.order)
	.map((g) => ({ index: g.order, key: g.key, label: g.message }))

// Skin tones in light→dark order, labels from messages.
const toneLabel = (key: string) =>
	messages.skinTones.find((t) => t.key === key)?.message ?? key
const skinTones = TONE_MODIFIERS.map((t) => ({
	slot: t.slot,
	key: t.key,
	label: toneLabel(t.key)
}))

/**
 * Five uniform-tone glyphs for a single-person tone-capable emoji, else null.
 * A variant qualifies when it carries EXACTLY ONE Fitzpatrick modifier and
 * removing it yields the base sequence — this matches both suffix tones
 * (`👋` → `👋🏻`) and infix ZWJ tones (`man: beard` → tone before the ZWJ),
 * while rejecting multi-person combos (couples/kiss/holding-hands) whose skins
 * carry two modifiers. Those 7 are deferred to a v2 refinement.
 */
function toneGlyphs(e: CompactEmoji): string[] | null {
	if (!e.skins || e.skins.length === 0) return null
	const base = stripVS(e.hexcode)
	const out: string[] = []
	for (const { mod } of TONE_MODIFIERS) {
		const skin = e.skins.find((s) => {
			const mods = s.hexcode.split('-').filter(isMod)
			return mods.length === 1 && mods[0] === mod && stripVS(s.hexcode.replace(`-${mod}`, '')) === base
		})
		if (!skin) return null
		out.push(skin.unicode)
	}
	return out
}

interface Entry {
	u: string
	n: string
	g: number
	k?: string
	s?: string[]
}

const entries: Entry[] = compact
	.filter((e) => e.group !== undefined && e.group !== COMPONENT_GROUP)
	.sort((a, b) => a.group! - b.group! || (a.order ?? 0) - (b.order ?? 0))
	.map((e) => {
		const entry: Entry = { u: e.unicode, n: e.label, g: e.group! }
		const kw = (e.tags ?? []).filter((t) => t && t !== e.label).join(' ')
		if (kw) entry.k = kw
		const tones = toneGlyphs(e)
		if (tones) entry.s = tones
		return entry
	})

const toneCount = entries.filter((e) => e.s).length

// Emit — one entry per line, compact object literals, minimal quoting.
const q = (s: string) => JSON.stringify(s)
const line = (e: Entry) => {
	const parts = [`u:${q(e.u)}`, `n:${q(e.n)}`, `g:${e.g}`]
	if (e.k) parts.push(`k:${q(e.k)}`)
	if (e.s) parts.push(`s:[${e.s.map(q).join(',')}]`)
	return `\t{${parts.join(',')}}`
}

const body = `// AUTO-GENERATED by scripts/generate-emoji-data.ts — DO NOT EDIT.
// Source: emojibase-data@16 (MIT), pruned from static/emoji/{compact,messages}.json.
// Regenerate: npm run generate:emoji-data
import type { EmojiEntry, EmojiGroup, SkinTone } from './types'

export const EMOJI_GROUPS: readonly EmojiGroup[] = ${JSON.stringify(groups)}

export const SKIN_TONES: readonly SkinTone[] = ${JSON.stringify(skinTones)}

export const EMOJI: readonly EmojiEntry[] = [
${entries.map(line).join(',\n')}
]
`

writeFileSync(resolve(root, 'src/libs/emoji/data.ts'), body, 'utf8')

console.log(
	`emoji-data: ${entries.length} pickable · ${toneCount} tone-capable · ${groups.length} groups → src/libs/emoji/data.ts`
)