termcard 0.0.0-stage → 0.2.1

package/src/config/schema.js

@@ -0,0 +1,298 @@
+/**
+ * Config validation and normalization.
+ *
+ * `normalizeConfig(raw)` returns a fully resolved config (template + overrides
+ * applied, defaults filled in, strings sanitized) or throws a `ConfigError`
+ * listing every problem found. Renderers only ever see normalized configs.
+ */
+
+import { sanitize, slugify, displayWidth } from '../text.js';
+import { themes, DEFAULT_THEME, THEME_ROLES } from './themes.js';
+import { templates, DEFAULT_TEMPLATE, CARD_OPTIONS, DEFAULT_MENU, MENU_ACTIONS } from './templates.js';
+import { identifyService } from './services.js';
+import { BUILT_IN_LANGUAGES } from '../i18n/index.js';
+
+export class ConfigError extends Error {
+  constructor(problems) {
+    super(`Invalid termcard config:\n${problems.map((p) => `  • ${p}`).join('\n')}`);
+    this.name = 'ConfigError';
+    this.problems = problems;
+  }
+}
+
+const TOP_LEVEL_KEYS = [
+  '$schema', 'name', 'title', 'tagline', 'description', 'organization', 'email', 'phone', 'website',
+  'location', 'links', 'language', 'strings', 'template', 'theme', 'icons', 'card', 'menu',
+];
+const LANG_CODE = /^[a-z]{2,3}(-[a-z0-9]{2,8})?$/i;
+// Deliberately stricter than RFC 5322: no characters that change the meaning of a mailto: URL (? & # % /).
+const EMAIL = /^[a-z0-9.!$'*+=^_`{|}~-]+@[a-z0-9-]+(\.[a-z0-9-]+)*\.[a-z]{2,}$/i;
+const PHONE = /^\+?[0-9][0-9 ().-]{3,24}$/;
+const HEX = /^#[0-9a-f]{6}$/i;
+const MAX_TEXT = 120;
+export const DESCRIPTION_LIMIT = 280;
+export const ICON_SETS = ['none', 'symbols', 'emoji', 'nerd'];
+
+/** Why a string is not an acceptable link, or undefined if it is. */
+export function urlProblem(value) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return 'must be a full URL, e.g. https://example.com';
+  }
+  if (!['https:', 'http:'].includes(parsed.protocol)) return 'must start with https:// or http://';
+  if (parsed.username || parsed.password) return 'must not contain credentials';
+  return undefined;
+}
+
+export const isEmail = (value) => value.length <= 254 && EMAIL.test(value);
+export const TEXT_LIMIT = MAX_TEXT;
+
+const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+
+/** Collects problems instead of throwing at the first one, so users can fix everything at once. */
+function createChecker() {
+  const problems = [];
+  const fail = (path, message) => {
+    problems.push(`${path}: ${message}`);
+  };
+
+  const text = (path, value, { required = false, max = MAX_TEXT } = {}) => {
+    if (value != null && typeof value !== 'string') return fail(path, 'must be a string');
+    const clean = value == null ? '' : sanitize(value);
+    if (!clean) return required ? fail(path, 'is required') : undefined;
+    if (clean.length > max) return fail(path, `must be at most ${max} characters`);
+    return clean;
+  };
+
+  const localized = (path, value, options) => {
+    if (value == null || typeof value === 'string') return text(path, value, options);
+    if (!isObject(value)) return fail(path, 'must be a string or an object of language → text');
+    const out = {};
+    for (const [lang, entry] of Object.entries(value)) {
+      if (!LANG_CODE.test(lang)) fail(`${path}.${lang}`, 'is not a valid language code');
+      else {
+        const clean = text(`${path}.${lang}`, entry, options);
+        if (clean) out[lang.toLowerCase()] = clean;
+      }
+    }
+    return Object.keys(out).length ? out : undefined;
+  };
+
+  const url = (path, value, { required = false } = {}) => {
+    const raw = text(path, value, { required, max: 2048 });
+    if (!raw) return undefined;
+    const problem = urlProblem(raw);
+    return problem ? fail(path, problem) : new URL(raw).href;
+  };
+
+  const oneOf = (path, value, allowed, fallback) => {
+    if (value === undefined) return fallback;
+    if (!allowed.includes(value)) return fail(path, `must be one of: ${allowed.join(', ')}`), fallback;
+    return value;
+  };
+
+  const unknownKeys = (path, value, allowed) => {
+    for (const key of Object.keys(value)) {
+      if (!allowed.includes(key)) fail(path ? `${path}.${key}` : key, 'is not a recognized option');
+    }
+  };
+
+  return { problems, fail, text, localized, url, oneOf, unknownKeys };
+}
+
+function normalizeLinks(c, raw) {
+  if (raw === undefined) return [];
+  if (!Array.isArray(raw)) return c.fail('links', 'must be an array'), [];
+  const seen = new Set();
+  // Ids set by the author win; generated ids step around them.
+  const explicitIds = new Set(raw.filter((e) => isObject(e) && typeof e.id === 'string').map((e) => e.id));
+  return raw.flatMap((entry, i) => {
+    const path = `links[${i}]`;
+    if (typeof entry === 'string') entry = { url: entry };
+    if (!isObject(entry)) return c.fail(path, 'must be a URL or { url, label?, id? }'), [];
+    c.unknownKeys(path, entry, ['url', 'label', 'id', 'icon']);
+    const href = c.url(`${path}.url`, entry.url, { required: true });
+    if (!href) return [];
+    const service = identifyService(href);
+    const explicit = c.text(`${path}.id`, entry.id, { max: 40 });
+    let id;
+    if (explicit) {
+      if (!/^[a-z0-9-]+$/i.test(explicit)) return c.fail(`${path}.id`, 'may only contain letters, digits and dashes'), [];
+      if (seen.has(explicit)) return c.fail(`${path}.id`, `"${explicit}" is already used by another link`), [];
+      id = explicit;
+    } else {
+      const auto = slugify(service.id) || 'link';
+      id = auto;
+      for (let n = 2; seen.has(id) || explicitIds.has(id); n++) id = `${auto}-${n}`;
+    }
+    seen.add(id);
+    const icon = c.text(`${path}.icon`, entry.icon, { max: 8 });
+    if (icon && displayWidth(icon) > 2) c.fail(`${path}.icon`, 'must be a single symbol (at most 2 columns wide)');
+    return [{ id, label: c.text(`${path}.label`, entry.label, { max: 40 }) ?? service.label, url: href, service: service.id, ...(icon && { icon }) }];
+  });
+}
+
+function normalizeLanguage(c, raw, strings) {
+  // "language": "de" is shorthand for a card that is only in German.
+  const value = raw === undefined ? {} : typeof raw === 'string' ? { default: raw, available: [raw] } : raw;
+  if (!isObject(value)) return c.fail('language', 'must be a language code or { default, available }'), { default: 'auto', available: ['en'] };
+  c.unknownKeys('language', value, ['default', 'available']);
+
+  const known = [...new Set([...BUILT_IN_LANGUAGES, ...Object.keys(strings)])];
+  let available = value.available ?? ['en'];
+  if (!Array.isArray(available) || !available.length) {
+    c.fail('language.available', 'must be a non-empty array of language codes');
+    available = ['en'];
+  }
+  available = available.map((l) => String(l).toLowerCase());
+  for (const lang of available) {
+    if (!known.includes(lang)) {
+      c.fail('language.available', `"${lang}" has no built-in translation; add it under "strings.${lang}"`);
+    }
+  }
+  const def = String(value.default ?? 'auto').toLowerCase();
+  if (def !== 'auto' && !available.includes(def)) c.fail('language.default', 'must be "auto" or one of language.available');
+  return { default: def, available: [...new Set(available)] };
+}
+
+function normalizeStrings(c, raw) {
+  if (raw === undefined) return {};
+  if (!isObject(raw)) return c.fail('strings', 'must be an object of language → { key: text }'), {};
+  const out = {};
+  for (const [lang, table] of Object.entries(raw)) {
+    if (!LANG_CODE.test(lang)) { c.fail(`strings.${lang}`, 'is not a valid language code'); continue; }
+    if (!isObject(table)) { c.fail(`strings.${lang}`, 'must be an object of key → text'); continue; }
+    out[lang.toLowerCase()] = Object.fromEntries(
+      Object.entries(table).flatMap(([key, v]) => {
+        const clean = c.text(`strings.${lang}.${key}`, v, { max: 200 });
+        return clean ? [[key, clean]] : [];
+      }),
+    );
+  }
+  return out;
+}
+
+function normalizeTheme(c, raw) {
+  if (raw === undefined) return { ...themes[DEFAULT_THEME] };
+  const value = typeof raw === 'string' ? { preset: raw } : raw;
+  if (!isObject(value)) return c.fail('theme', 'must be a preset name or an object'), { ...themes[DEFAULT_THEME] };
+  c.unknownKeys('theme', value, ['preset', ...THEME_ROLES]);
+  const preset = c.oneOf('theme.preset', value.preset, Object.keys(themes), DEFAULT_THEME);
+  const theme = { ...themes[preset] };
+  for (const role of THEME_ROLES) {
+    if (value[role] === undefined) continue;
+    if (typeof value[role] === 'string' && HEX.test(value[role])) theme[role] = value[role].toLowerCase();
+    else if (value[role] === 'default') theme[role] = 'default';
+    else c.fail(`theme.${role}`, 'must be a hex color like "#d7af5f" or "default" (the terminal\'s own color)');
+  }
+  return theme;
+}
+
+function normalizeCard(c, raw, template, fieldIds) {
+  // "card": false shows only the menu (with a one-line header).
+  if (raw === false) return { ...templates[template], enabled: false, fields: fieldIds };
+  const value = raw === undefined || raw === true ? {} : raw;
+  if (!isObject(value)) return c.fail('card', 'must be false or an object'), { ...templates[template], enabled: true, fields: fieldIds };
+  const options = Object.keys(templates.classic);
+  c.unknownKeys('card', value, [...options, 'fields']);
+
+  const card = { ...templates[template], enabled: true };
+  for (const [key, allowed] of Object.entries(CARD_OPTIONS)) card[key] = c.oneOf(`card.${key}`, value[key], allowed, card[key]);
+  for (const key of ['splitName', 'accentRule', 'labels']) {
+    if (value[key] === undefined) continue;
+    if (typeof value[key] === 'boolean') card[key] = value[key];
+    else c.fail(`card.${key}`, 'must be true or false');
+  }
+  if (value.padding !== undefined) {
+    if (Number.isInteger(value.padding) && value.padding >= 0 && value.padding <= 8) card.padding = value.padding;
+    else c.fail('card.padding', 'must be an integer between 0 and 8');
+  }
+  if (value.width !== undefined) {
+    if (value.width === 'auto' || (Number.isInteger(value.width) && value.width >= 20 && value.width <= 120)) card.width = value.width;
+    else c.fail('card.width', 'must be "auto" or an integer between 20 and 120');
+  }
+
+  card.fields = fieldIds;
+  if (value.fields !== undefined) {
+    if (!Array.isArray(value.fields)) c.fail('card.fields', 'must be an array');
+    else {
+      card.fields = value.fields.filter((f) => {
+        if (fieldIds.includes(f)) return true;
+        c.fail('card.fields', `unknown field "${f}" (available: ${fieldIds.join(', ') || 'none'})`);
+        return false;
+      });
+    }
+  }
+  return card;
+}
+
+function normalizeMenu(c, raw, linkIds) {
+  if (raw === false) return { enabled: false, items: [] };
+  const value = raw === undefined || raw === true ? {} : raw;
+  if (!isObject(value)) return c.fail('menu', 'must be false or { items }'), { enabled: true, items: DEFAULT_MENU };
+  c.unknownKeys('menu', value, ['items']);
+  if (value.items === undefined) return { enabled: true, items: DEFAULT_MENU };
+  if (!Array.isArray(value.items)) return c.fail('menu.items', 'must be an array'), { enabled: true, items: DEFAULT_MENU };
+
+  const items = value.items.flatMap((item, i) => {
+    const path = `menu.items[${i}]`;
+    if (typeof item === 'string') {
+      if (MENU_ACTIONS.includes(item)) return [item];
+      const link = item.startsWith('link:') && item.slice(5);
+      if (link && linkIds.includes(link)) return [item];
+      c.fail(path, `unknown item "${item}" (use ${MENU_ACTIONS.join(', ')} or link:<id>)`);
+      return [];
+    }
+    if (!isObject(item)) return c.fail(path, 'must be an action name or { label, url, hint? }'), [];
+    c.unknownKeys(path, item, ['label', 'url', 'hint']);
+    const label = c.localized(`${path}.label`, item.label);
+    const href = c.url(`${path}.url`, item.url, { required: true });
+    if (!label) c.fail(`${path}.label`, 'is required');
+    return label && href ? [{ label, url: href, hint: c.localized(`${path}.hint`, item.hint) }] : [];
+  });
+  if (!items.length) c.fail('menu.items', 'must contain at least one item (or set "menu": false)');
+  return { enabled: true, items };
+}
+
+export function normalizeConfig(raw) {
+  if (!isObject(raw)) throw new ConfigError(['config must be a JSON object']);
+  const c = createChecker();
+  c.unknownKeys('', raw, TOP_LEVEL_KEYS);
+
+  const config = {
+    name: c.text('name', raw.name, { required: true, max: 80 }),
+    title: c.localized('title', raw.title),
+    tagline: c.localized('tagline', raw.tagline),
+    description: c.localized('description', raw.description, { max: DESCRIPTION_LIMIT }),
+    organization: c.text('organization', raw.organization),
+    email: c.text('email', raw.email, { max: 254 }),
+    phone: c.text('phone', raw.phone, { max: 30 }),
+    website: c.url('website', raw.website),
+    location: c.localized('location', raw.location),
+    links: normalizeLinks(c, raw.links),
+  };
+  if (config.email && !isEmail(config.email)) c.fail('email', 'is not a valid email address');
+  if (config.phone && !PHONE.test(config.phone)) c.fail('phone', 'may only contain digits, spaces, + ( ) - .');
+
+  config.strings = normalizeStrings(c, raw.strings);
+  config.language = normalizeLanguage(c, raw.language, config.strings);
+  config.template = c.oneOf('template', raw.template, Object.keys(templates), DEFAULT_TEMPLATE);
+  config.theme = normalizeTheme(c, raw.theme);
+  config.icons = c.oneOf('icons', raw.icons, ICON_SETS, 'none');
+
+  const fieldIds = [
+    ...(config.website ? ['website'] : []),
+    ...(config.email ? ['email'] : []),
+    ...(config.phone ? ['phone'] : []),
+    ...config.links.map((l) => l.id),
+    ...(config.location ? ['location'] : []),
+  ];
+  config.card = normalizeCard(c, raw.card, config.template, fieldIds);
+  config.menu = normalizeMenu(c, raw.menu, config.links.map((l) => l.id));
+  if (!config.card.enabled && !config.menu.enabled) c.fail('card', 'cannot be false while the menu is off too');
+
+  if (c.problems.length) throw new ConfigError(c.problems);
+  return Object.freeze(config);
+}

package/src/config/services.js

@@ -0,0 +1,38 @@
+/** Well-known services, used to give links a readable label and a stable id automatically. */
+
+const services = [
+  ['linkedin', 'LinkedIn', ['linkedin.com']],
+  ['github', 'GitHub', ['github.com']],
+  ['gitlab', 'GitLab', ['gitlab.com']],
+  ['x', 'X', ['x.com', 'twitter.com']],
+  ['bluesky', 'Bluesky', ['bsky.app']],
+  ['threads', 'Threads', ['threads.net', 'threads.com']],
+  ['instagram', 'Instagram', ['instagram.com']],
+  ['facebook', 'Facebook', ['facebook.com']],
+  ['youtube', 'YouTube', ['youtube.com', 'youtu.be']],
+  ['tiktok', 'TikTok', ['tiktok.com']],
+  ['behance', 'Behance', ['behance.net']],
+  ['dribbble', 'Dribbble', ['dribbble.com']],
+  ['medium', 'Medium', ['medium.com']],
+  ['devto', 'DEV', ['dev.to']],
+  ['stackoverflow', 'Stack Overflow', ['stackoverflow.com']],
+  ['npm', 'npm', ['npmjs.com']],
+  ['codepen', 'CodePen', ['codepen.io']],
+  ['figma', 'Figma', ['figma.com']],
+  ['producthunt', 'Product Hunt', ['producthunt.com']],
+  ['calendly', 'Calendly', ['calendly.com']],
+  ['cal', 'Cal.com', ['cal.com']],
+];
+
+export function identifyService(url) {
+  let host;
+  try {
+    host = new URL(url).hostname.replace(/^www\./, '');
+  } catch {
+    return null;
+  }
+  for (const [id, label, hosts] of services) {
+    if (hosts.some((h) => host === h || host.endsWith(`.${h}`))) return { id, label };
+  }
+  return { id: host.split('.').slice(-2, -1)[0] || host, label: host };
+}

package/src/config/templates.js

@@ -0,0 +1,56 @@
+/**
+ * Templates are presets for the `card` section. Every option can still be
+ * overridden individually in the config.
+ */
+
+export const templates = {
+  // Business-card look: letter-spaced name, generous whitespace.
+  classic: {
+    border: 'rounded',
+    nameStyle: 'spaced',
+    splitName: true,
+    spacing: 'relaxed',
+    accentRule: true,
+    labels: true,
+    locationAlign: 'right',
+    padding: 4,
+    width: 56,
+  },
+  // Denser layout for longer names or smaller terminals.
+  compact: {
+    border: 'rounded',
+    nameStyle: 'plain',
+    splitName: false,
+    spacing: 'compact',
+    accentRule: false,
+    labels: true,
+    locationAlign: 'left',
+    padding: 2,
+    width: 'auto',
+  },
+  // No frame, no labels — just the essentials.
+  minimal: {
+    border: 'none',
+    nameStyle: 'plain',
+    splitName: false,
+    spacing: 'compact',
+    accentRule: false,
+    labels: false,
+    locationAlign: 'left',
+    padding: 0,
+    width: 'auto',
+  },
+};
+
+export const DEFAULT_TEMPLATE = 'classic';
+
+export const CARD_OPTIONS = {
+  border: ['rounded', 'square', 'double', 'heavy', 'none'],
+  nameStyle: ['spaced', 'uppercase', 'plain'],
+  spacing: ['relaxed', 'compact'],
+  locationAlign: ['left', 'right'],
+};
+
+/** Default menu: every action that has the data it needs is shown, in this order. */
+export const DEFAULT_MENU = ['contact', 'save', 'website', 'links', 'copy-email', 'language', 'exit'];
+export const MENU_ACTIONS = ['contact', 'save', 'website', 'links', 'copy-email', 'copy-phone', 'language', 'exit'];

package/src/config/themes.js

@@ -0,0 +1,35 @@
+/**
+ * Color themes, named after the four seasons and the turns between them.
+ *
+ * Only the accent changes between themes. Text uses the terminal's own
+ * foreground color ("default"), and the grays are mid-tones, so every theme
+ * reads well on both dark and light terminal backgrounds. Accents are exact
+ * xterm-256 colors, so they look the same in 256-color and true-color terminals.
+ */
+
+const neutral = { text: 'default', muted: '#8a8a8a', faint: '#6c6c6c' };
+
+export const themes = {
+  thaw: { ...neutral, accent: '#5fafaf' }, //       late winter → spring: meltwater teal
+  bloom: { ...neutral, accent: '#87af5f' }, //      spring: fresh leaves
+  blossom: { ...neutral, accent: '#d787af' }, //    spring → summer: petals
+  solstice: { ...neutral, accent: '#d7af5f' }, //   summer: midday gold (default)
+  ember: { ...neutral, accent: '#d7875f' }, //      summer → autumn: last warm light
+  harvest: { ...neutral, accent: '#af875f' }, //    autumn: wheat and wood
+  frost: { ...neutral, accent: '#87afd7' }, //      autumn → winter: first ice
+  midwinter: { ...neutral, accent: '#8787af' }, //  winter: long blue dusk
+};
+
+export const THEME_DESCRIPTIONS = {
+  thaw: 'late winter → spring, meltwater teal',
+  bloom: 'spring, fresh green',
+  blossom: 'spring → summer, petal pink',
+  solstice: 'summer, midday gold',
+  ember: 'summer → autumn, warm copper',
+  harvest: 'autumn, wheat brown',
+  frost: 'autumn → winter, ice blue',
+  midwinter: 'winter, dusk lavender',
+};
+
+export const DEFAULT_THEME = 'solstice';
+export const THEME_ROLES = ['text', 'muted', 'faint', 'accent'];

package/src/i18n/index.js

@@ -0,0 +1,72 @@
+/**
+ * Internationalization: built-in locales, string lookup with per-card
+ * overrides, and language detection from the user's environment.
+ *
+ * Terminals have no translation feature of their own, so the language is
+ * chosen from (in order): --lang flag, TERMCARD_LANG, the POSIX locale
+ * variables, the OS locale reported by Intl, then the card's default.
+ */
+
+import { format } from '../text.js';
+import en from './locales/en.js';
+import tr from './locales/tr.js';
+import de from './locales/de.js';
+import es from './locales/es.js';
+import fr from './locales/fr.js';
+
+const LOCALES = { en, tr, de, es, fr };
+export const BUILT_IN_LANGUAGES = Object.keys(LOCALES);
+
+/** Returns a translator bound to one language, honoring the card's own string overrides. */
+export function createTranslator(lang, overrides = {}) {
+  const tables = [overrides[lang], LOCALES[lang], overrides.en, en].filter(Boolean);
+  return (key, values) => {
+    for (const table of tables) if (table[key] !== undefined) return format(table[key], values);
+    return key;
+  };
+}
+
+/** Native display name of a language, e.g. "Türkçe". */
+export const languageName = (lang, overrides = {}) =>
+  overrides[lang]?.['meta.name'] ?? LOCALES[lang]?.['meta.name'] ?? lang.toUpperCase();
+
+/** "tr_TR.UTF-8" → "tr", "pt-BR" → "pt". Returns undefined for C/POSIX or empty values. */
+function baseLanguage(locale) {
+  if (!locale || /^(C|POSIX)([._].*)?$/i.test(locale)) return undefined;
+  return locale.split(/[_.@-]/)[0].toLowerCase() || undefined;
+}
+
+/**
+ * Picks the language to show.
+ * @param {{ default: string, available: string[] }} language normalized config.language
+ * @param {{ flag?: string, env?: NodeJS.ProcessEnv }} context
+ */
+export function detectLanguage(language, { flag, env = {} } = {}) {
+  const { available } = language;
+  const pick = (code) => (code && available.includes(code) ? code : undefined);
+
+  const explicit = pick(flag?.toLowerCase()) ?? pick(env.TERMCARD_LANG?.toLowerCase());
+  if (explicit) return explicit;
+  if (language.default !== 'auto') return language.default;
+
+  const candidates = [env.LC_ALL, env.LC_MESSAGES, env.LANG, ...(env.LANGUAGE?.split(':') ?? [])];
+  try {
+    candidates.push(Intl.DateTimeFormat().resolvedOptions().locale);
+  } catch {
+    // Intl unavailable (very old runtimes): ignore.
+  }
+  for (const candidate of candidates) {
+    const found = pick(baseLanguage(candidate));
+    if (found) return found;
+  }
+  return available.includes('en') ? 'en' : available[0];
+}
+
+/** Language from an HTTP Accept-Language header (used by the web/curl integrations). */
+export function languageFromHeader(header = '', available = ['en']) {
+  for (const part of header.split(',')) {
+    const code = baseLanguage(part.split(';')[0].trim());
+    if (code && available.includes(code)) return code;
+  }
+  return available.includes('en') ? 'en' : available[0];
+}

package/src/i18n/locales/de.js

@@ -0,0 +1,39 @@
+export default {
+  'meta.name': 'Deutsch',
+  'label.website': 'Web',
+  'label.email': 'E-Mail',
+  'label.phone': 'Telefon',
+  'action.contact': 'Kontakt aufnehmen',
+  'hint.contact': 'Öffnet eine neue Nachricht in Ihrem E-Mail-Programm.',
+  'action.save': 'Kontakt speichern',
+  'hint.save': 'Fügt die Visitenkarte (vCard) Ihrem Adressbuch hinzu.',
+  'action.website': 'Website besuchen',
+  'hint.website': 'Öffnet {host} in Ihrem Browser.',
+  'action.link': '{label}-Profil ansehen',
+  'hint.link': 'Öffnet {host} in Ihrem Browser.',
+  'action.copyEmail': 'E-Mail-Adresse kopieren',
+  'hint.copyEmail': 'Kopiert die Adresse in die Zwischenablage.',
+  'action.copyPhone': 'Telefonnummer kopieren',
+  'hint.copyPhone': 'Kopiert die Nummer in die Zwischenablage.',
+  'action.language': 'Sprache',
+  'hint.language': 'Zeigt die Karte in einer anderen Sprache.',
+  'action.back': 'Zurück',
+  'hint.back': 'Zurück zum Hauptmenü.',
+  'action.exit': 'Beenden',
+  'hint.exit': 'Schließt die Karte.',
+  'status.contact': 'E-Mail-Entwurf geöffnet.',
+  'status.contactFailed': 'E-Mail-Programm konnte nicht geöffnet werden — {value}',
+  'status.save': 'Visitenkarte geöffnet.',
+  'status.saveFailed': 'Visitenkarte gespeichert unter {value}',
+  'status.saveError': 'Visitenkarte konnte nicht erstellt werden.',
+  'status.browser': 'Im Browser geöffnet.',
+  'status.browserFailed': 'Browser konnte nicht geöffnet werden — {value}',
+  'status.copied': 'In die Zwischenablage kopiert.',
+  'status.copyFailed': 'Zwischenablage nicht verfügbar — {value}',
+  'status.language': 'Sprache geändert.',
+  'keys.navigate': 'navigieren',
+  'keys.select': 'auswählen',
+  'keys.quit': 'beenden',
+  'keys.back': 'zurück',
+  'mail.subject': 'Hallo',
+};

package/src/i18n/locales/en.js

@@ -0,0 +1,39 @@
+export default {
+  'meta.name': 'English',
+  'label.website': 'Web',
+  'label.email': 'Email',
+  'label.phone': 'Phone',
+  'action.contact': 'Get in touch',
+  'hint.contact': 'Opens a new message in your email client.',
+  'action.save': 'Save contact',
+  'hint.save': 'Adds the contact card (vCard) to your address book.',
+  'action.website': 'Visit website',
+  'hint.website': 'Opens {host} in your browser.',
+  'action.link': 'View {label} profile',
+  'hint.link': 'Opens {host} in your browser.',
+  'action.copyEmail': 'Copy email address',
+  'hint.copyEmail': 'Copies the address to your clipboard.',
+  'action.copyPhone': 'Copy phone number',
+  'hint.copyPhone': 'Copies the number to your clipboard.',
+  'action.language': 'Language',
+  'hint.language': 'Show this card in another language.',
+  'action.back': 'Back',
+  'hint.back': 'Return to the main menu.',
+  'action.exit': 'Exit',
+  'hint.exit': 'Closes the card.',
+  'status.contact': 'Email draft opened.',
+  'status.contactFailed': 'Could not open an email client — {value}',
+  'status.save': 'Contact card opened.',
+  'status.saveFailed': 'Contact card saved to {value}',
+  'status.saveError': 'Could not create the contact card.',
+  'status.browser': 'Opened in your browser.',
+  'status.browserFailed': 'Could not open a browser — {value}',
+  'status.copied': 'Copied to clipboard.',
+  'status.copyFailed': 'Clipboard unavailable — {value}',
+  'status.language': 'Language changed.',
+  'keys.navigate': 'navigate',
+  'keys.select': 'select',
+  'keys.quit': 'quit',
+  'keys.back': 'back',
+  'mail.subject': 'Hello',
+};

package/src/i18n/locales/es.js

@@ -0,0 +1,39 @@
+export default {
+  'meta.name': 'Español',
+  'label.website': 'Web',
+  'label.email': 'Correo',
+  'label.phone': 'Teléfono',
+  'action.contact': 'Ponerse en contacto',
+  'hint.contact': 'Abre un mensaje nuevo en tu cliente de correo.',
+  'action.save': 'Guardar contacto',
+  'hint.save': 'Añade la tarjeta de contacto (vCard) a tu agenda.',
+  'action.website': 'Visitar sitio web',
+  'hint.website': 'Abre {host} en tu navegador.',
+  'action.link': 'Ver perfil de {label}',
+  'hint.link': 'Abre {host} en tu navegador.',
+  'action.copyEmail': 'Copiar correo electrónico',
+  'hint.copyEmail': 'Copia la dirección al portapapeles.',
+  'action.copyPhone': 'Copiar número de teléfono',
+  'hint.copyPhone': 'Copia el número al portapapeles.',
+  'action.language': 'Idioma',
+  'hint.language': 'Muestra la tarjeta en otro idioma.',
+  'action.back': 'Volver',
+  'hint.back': 'Vuelve al menú principal.',
+  'action.exit': 'Salir',
+  'hint.exit': 'Cierra la tarjeta.',
+  'status.contact': 'Borrador de correo abierto.',
+  'status.contactFailed': 'No se pudo abrir un cliente de correo — {value}',
+  'status.save': 'Tarjeta de contacto abierta.',
+  'status.saveFailed': 'Tarjeta de contacto guardada en {value}',
+  'status.saveError': 'No se pudo crear la tarjeta de contacto.',
+  'status.browser': 'Abierto en tu navegador.',
+  'status.browserFailed': 'No se pudo abrir un navegador — {value}',
+  'status.copied': 'Copiado al portapapeles.',
+  'status.copyFailed': 'Portapapeles no disponible — {value}',
+  'status.language': 'Idioma cambiado.',
+  'keys.navigate': 'navegar',
+  'keys.select': 'seleccionar',
+  'keys.quit': 'salir',
+  'keys.back': 'volver',
+  'mail.subject': 'Hola',
+};

package/src/i18n/locales/fr.js

@@ -0,0 +1,39 @@
+export default {
+  'meta.name': 'Français',
+  'label.website': 'Web',
+  'label.email': 'E-mail',
+  'label.phone': 'Téléphone',
+  'action.contact': 'Prendre contact',
+  'hint.contact': 'Ouvre un nouveau message dans votre messagerie.',
+  'action.save': 'Enregistrer le contact',
+  'hint.save': 'Ajoute la carte de visite (vCard) à votre carnet d’adresses.',
+  'action.website': 'Visiter le site web',
+  'hint.website': 'Ouvre {host} dans votre navigateur.',
+  'action.link': 'Voir le profil {label}',
+  'hint.link': 'Ouvre {host} dans votre navigateur.',
+  'action.copyEmail': 'Copier l’adresse e-mail',
+  'hint.copyEmail': 'Copie l’adresse dans le presse-papiers.',
+  'action.copyPhone': 'Copier le numéro de téléphone',
+  'hint.copyPhone': 'Copie le numéro dans le presse-papiers.',
+  'action.language': 'Langue',
+  'hint.language': 'Affiche la carte dans une autre langue.',
+  'action.back': 'Retour',
+  'hint.back': 'Revient au menu principal.',
+  'action.exit': 'Quitter',
+  'hint.exit': 'Ferme la carte.',
+  'status.contact': 'Brouillon d’e-mail ouvert.',
+  'status.contactFailed': 'Impossible d’ouvrir une messagerie — {value}',
+  'status.save': 'Carte de visite ouverte.',
+  'status.saveFailed': 'Carte de visite enregistrée dans {value}',
+  'status.saveError': 'Impossible de créer la carte de visite.',
+  'status.browser': 'Ouvert dans votre navigateur.',
+  'status.browserFailed': 'Impossible d’ouvrir un navigateur — {value}',
+  'status.copied': 'Copié dans le presse-papiers.',
+  'status.copyFailed': 'Presse-papiers indisponible — {value}',
+  'status.language': 'Langue modifiée.',
+  'keys.navigate': 'naviguer',
+  'keys.select': 'choisir',
+  'keys.quit': 'quitter',
+  'keys.back': 'retour',
+  'mail.subject': 'Bonjour',
+};