roleplay-data 0.1.0

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "roleplay-data",
+  "version": "0.1.0",
+  "description": "Base de données RP open source : items, véhicules, thèmes (images + renommages) et i18n (fr/en requis). Source de vérité unique, consommable en package npm, seed SQL/MongoDB ou archive d'assets.",
+  "type": "module",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "exports": {
+    ".": "./src/index.js",
+    "./items.json": "./catalog/items.json",
+    "./vehicles.json": "./catalog/vehicles.json",
+    "./themes": "./themes/themes.json",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "catalog",
+    "themes",
+    "src",
+    "assets/README.md",
+    "README.md",
+    "CREDITS.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "validate": "node scripts/validate.mjs",
+    "build": "node scripts/build-release.mjs",
+    "build:assets": "node scripts/build-release.mjs --with-assets",
+    "migrate:items": "node scripts/migrate-items.mjs",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "roleplay",
+    "rp",
+    "items",
+    "vehicles",
+    "gta",
+    "discord-bot",
+    "fivem",
+    "database",
+    "i18n",
+    "themes"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0"
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Types publics du package roleplay-data.
+ * Chaque type reflète fidèlement le schéma JSON correspondant (catalog/schemas/*).
+ */
+export type Locale = 'fr' | 'en' | (string & {});
+
+/** Objet texte localisé. fr + en sont toujours présents. */
+export type Localized = {
+  fr: string;
+  en: string;
+  [locale: string]: string;
+};
+
+export type DrugProperties = {
+  type: string;
+  duration: number;
+  [key: string]: unknown;
+};
+
+/** Toute propriété libre laissée au projet consommateur. */
+export type CustomProperties = Record<string, unknown>;
+
+export type ItemMetadata = {
+  /** Identité du monde réel (modèle d'arme, calibre, fabricant…). */
+  irl?: Record<string, unknown>;
+  /** Provenance de l'item. */
+  source?: string;
+  [key: string]: unknown;
+};
+
+export type Item = {
+  /** Identifiant canonique (snake_case). Ne change jamais. */
+  id: string;
+  name: Localized;
+  description: Localized;
+  /** Fichier dans le pack d'images par défaut (themes/gta-artwork). */
+  image: string;
+  emoji?: string;
+  weight: number;
+  food: number;
+  thirst: number;
+  drug: DrugProperties | null;
+  stackable: boolean;
+  usable: boolean;
+  tags: string[];
+  metadata: ItemMetadata;
+  customProperties: CustomProperties;
+};
+
+export type ItemsCatalog = {
+  items: Item[];
+};
+
+export type VehicleCategory = 'car' | 'bike' | 'truck' | 'special';
+
+export type Vehicle = {
+  id: string;
+  brand: Localized;
+  model: Localized;
+  category: VehicleCategory;
+  image: string;
+  seats: number;
+  massKg: number;
+  fuelCapacity: number;
+  maxSpeed: number;
+  cargo: {
+    maxSlots: number;
+    maxWeightKg: number;
+  };
+  metadata: ItemMetadata;
+  customProperties: CustomProperties;
+};
+
+export type VehiclesCatalog = {
+  vehicles: Vehicle[];
+};
+
+export type ThemeScope = 'items' | 'vehicles';
+
+export type ThemeRegistryEntry = {
+  label: Localized;
+  description?: Localized;
+  scope: ThemeScope[];
+  image?: string;
+  license?: string;
+  attribution?: string;
+};
+
+export type ThemeRegistry = {
+  themes: Record<string, ThemeRegistryEntry>;
+};
+
+export type ThemeOverride = {
+  id: string;
+  name?: Localized;
+  description?: Localized;
+  image?: string;
+  emoji?: string;
+  weight?: number;
+  food?: number;
+  thirst?: number;
+  drug?: DrugProperties | null;
+  stackable?: boolean;
+  usable?: boolean;
+  tags?: string[];
+  metadata?: ItemMetadata;
+  customProperties?: CustomProperties;
+};
+
+export type ThemeExclusiveItem = ThemeOverride & {
+  id: string;
+  name: Localized;
+  image: string;
+  weight: number;
+};
+
+export type Theme = {
+  overrides: ThemeOverride[];
+  exclusiveItems: ThemeExclusiveItem[];
+  virtualIds?: string[];
+};
+
+/* ------------------------------------------------------------------ *
+ * Fonctions runtime (implémentées dans index.js / localize.js / resolve.js)
+ * ------------------------------------------------------------------ */
+
+/** Liste ordonnée des items canoniques. */
+export function getItems(): Item[];
+/** Item canonique par id, ou null. */
+export function getItem(id: string | null | undefined): Item | null;
+/** Liste ordonnée des modèles de véhicules. */
+export function getVehicles(): Vehicle[];
+/** Véhicule par id, ou null. */
+export function getVehicle(id: string | null | undefined): Vehicle | null;
+/** Registre des thèmes (id → métadonnées). */
+export function getThemeRegistry(): Record<string, ThemeRegistryEntry>;
+/** Ids des thèmes (thème par défaut en premier), filtrés par scope. */
+export function listThemeIds(scope?: ThemeScope): string[];
+/** Thème complet (overrides + exclusifs) par id — thème inconnu = vide. */
+export function getTheme(themeId: string | null | undefined): Theme;
+/** Item résolu pour un thème (override + exclusif gérés), ou null. */
+export function getThemedItem(itemId: string, themeId?: string | null | undefined): Item | null;
+/** Nom localisé effectif d'un item pour un thème et une locale. */
+export function getThemedItemName(itemId: string, themeId: string, locale?: string): string;
+/** Meilleure image disponible : thème → gta-artwork → no_image. */
+export function getItemImage(
+  itemId: string,
+  themeId?: string | null | undefined,
+  opts?: { assetsRoot?: string }
+): string;
+/** Libère les caches (rechargement à chaud). */
+export function clearCache(): void;
+
+/** Outils i18n. */
+export function translate(localized: Localized | null | undefined, locale?: string): string;
+export function itemLocalizedName(
+  item: { name?: Localized } | null | undefined,
+  locale?: string
+): string;
+export function itemLocalizedDescription(
+  item: { description?: Localized } | null | undefined,
+  locale?: string
+): string;
+export function vehicleLocalizedName(
+  vehicle: { brand?: Localized; model?: Localized } | null | undefined,
+  locale?: string
+): string;
+
+/** Résolution de thèmes (packs d'images + renommages + exclusifs). */
+export const DEFAULT_IMAGE_THEME: string;
+export const NO_IMAGE: string;
+export function normalizeThemeId(raw: unknown): string;
+export function resolveThemedImage(
+  imageFile: string | null | undefined,
+  themeId?: string | null | undefined,
+  opts?: { assetsRoot?: string }
+): string;
+
+/** Namespaces utilitaires (équivalents « module » des JS compacts). */
+import * as localizeNs from './localize.js';
+import * as resolverNs from './resolve.js';
+export { localizeNs as localize, resolverNs as resolver };

package/src/index.js

@@ -0,0 +1,131 @@
+/**
+ * roleplay-data — source de vérité RP (items, véhicules, thèmes).
+ *
+ * Ce module charge les données JSON du package (catalog/ + themes/) et expose
+ * une API typée pour les consommer : recherche d'item/véhicule, résolution
+ * d'images et de renommages par thème, i18n.
+ *
+ * Les données sont mises en cache en mémoire la première fois qu'elles sont
+ * lues — rechargement possible via clearCache().
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve as pathResolve } from 'node:path';
+
+import * as localize from './localize.js';
+import * as resolver from './resolve.js';
+
+export { localize, resolver };
+export {
+  DEFAULT_IMAGE_THEME,
+  NO_IMAGE,
+  normalizeThemeId,
+  resolveThemedImage,
+} from './resolve.js';
+export {
+  localize as translate,
+  itemLocalizedName,
+  itemLocalizedDescription,
+  vehicleLocalizedName,
+} from './localize.js';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = pathResolve(here, '..');
+
+const cache = {
+  items: null,
+  vehicles: null,
+  registry: null,
+  themes: new Map(),
+};
+
+function readJson(rel) {
+  return JSON.parse(readFileSync(join(REPO_ROOT, rel), 'utf-8'));
+}
+
+function lazy(key, rel) {
+  if (cache[key] === null) cache[key] = readJson(rel);
+  return cache[key];
+}
+
+/** Liste ordonnée des items canoniques. */
+export function getItems() {
+  return lazy('items', 'catalog/items.json').items;
+}
+
+/** Item canonique par id, ou null. */
+export function getItem(id) {
+  if (!id) return null;
+  return getItems().find((i) => i.id === id) || null;
+}
+
+/** Liste ordonnée des modèles de véhicules. */
+export function getVehicles() {
+  return lazy('vehicles', 'catalog/vehicles.json').vehicles;
+}
+
+/** Véhicule par id, ou null. */
+export function getVehicle(id) {
+  if (!id) return null;
+  return getVehicles().find((v) => v.id === id) || null;
+}
+
+/** Registre des thèmes (métadonnées : label, scope, licence, attribution…). */
+export function getThemeRegistry() {
+  return lazy('registry', 'themes/themes.json').themes;
+}
+
+/** Ids des thèmes, triés avec le thème par défaut en premier. */
+export function listThemeIds(scope = 'items') {
+  const registry = getThemeRegistry();
+  const ids = Object.keys(registry).filter(
+    (id) => !scope || !Array.isArray(registry[id]?.scope) || registry[id].scope.includes(scope)
+  );
+  return ids.sort((a, b) => {
+    if (a === resolver.DEFAULT_IMAGE_THEME) return -1;
+    if (b === resolver.DEFAULT_IMAGE_THEME) return 1;
+    return a.localeCompare(b);
+  });
+}
+
+/** Thème complet (overrides + exclusifs) par id. Fichier introuvable → thème vide. */
+export function getTheme(themeId) {
+  const id = resolver.normalizeThemeId(themeId);
+  if (cache.themes.has(id)) return cache.themes.get(id);
+  let theme = null;
+  try {
+    theme = readJson(`themes/${id}.json`);
+  } catch {
+    theme = { overrides: [], exclusiveItems: [] };
+  }
+  cache.themes.set(id, theme);
+  return theme;
+}
+
+/** Item résolu pour un thème (override + exclusif gérés), ou null. */
+export function getThemedItem(itemId, themeId) {
+  return resolver.resolveThemedItem(getItems(), itemId, getTheme(themeId));
+}
+
+/** Nom localisé effectif d'un item pour un thème et une locale. */
+export function getThemedItemName(itemId, themeId, locale) {
+  const themed = getThemedItem(itemId, themeId);
+  return localize.itemLocalizedName(themed, locale);
+}
+
+/** Meilleure image disponible pour un item/thème : thème → gta-artwork → no_image. */
+export function getItemImage(itemId, themeId, { assetsRoot } = {}) {
+  const item = getThemedItem(itemId, themeId) || getItem(itemId);
+  if (!item) return resolver.NO_IMAGE;
+  const root = assetsRoot ?? join(REPO_ROOT, 'assets');
+  return resolver.resolveThemedImage(item.image, themeId, { assetsRoot: root });
+}
+
+/** Libère tous les caches (utile en rechargement à chaud). */
+export function clearCache() {
+  cache.items = null;
+  cache.vehicles = null;
+  cache.registry = null;
+  cache.themes.clear();
+  if (typeof resolver._clearExistsCache === 'function') resolver._clearExistsCache();
+}

package/src/localize.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Déclarations typées des helpers i18n (implémentation : localize.js).
+ * Évite toute circularité : les types structures sont répétés volontairement.
+ */
+
+export type LocalizedLike = {
+  fr?: string;
+  en?: string;
+  [locale: string]: string | undefined;
+};
+
+/** Renvoie la traduction d'un objet localisé pour une locale (fallback en). */
+export function localize(localized: LocalizedLike | null | undefined, locale?: string): string;
+
+/** Nom localisé d'un item (fallback en). */
+export function itemLocalizedName(
+  item: { name?: LocalizedLike } | null | undefined,
+  locale?: string
+): string;
+
+/** Description localisée d'un item (fallback en). */
+export function itemLocalizedDescription(
+  item: { description?: LocalizedLike } | null | undefined,
+  locale?: string
+): string;
+
+/** Nom localisé brand + model d'un véhicule. */
+export function vehicleLocalizedName(
+  vehicle: { brand?: LocalizedLike; model?: LocalizedLike } | null | undefined,
+  locale?: string
+): string;

package/src/localize.js

@@ -0,0 +1,28 @@
+/**
+ * Helpers de localisation.
+ * Conventions : fr + en toujours présents ; la locale demandée retombe sur en.
+ */
+/** Renvoie la traduction d'un objet localisé pour une locale (fallback en). */
+export function localize(localized, locale) {
+  const loc = !locale || typeof locale !== 'string' ? 'en' : locale;
+  if (!localized) return '';
+  return localized[loc] || localized.en || localized.fr || '';
+}
+
+/** Nom localisé d'un item (fallback en). */
+export function itemLocalizedName(item, locale) {
+  return localize(item?.name, locale);
+}
+
+/** Description localisée d'un item (fallback en). */
+export function itemLocalizedDescription(item, locale) {
+  return localize(item?.description, locale);
+}
+
+/** Nom localisé brand + model d'un véhicule. */
+export function vehicleLocalizedName(vehicle, locale) {
+  if (!vehicle) return '';
+  const brand = localize(vehicle.brand, locale);
+  const model = localize(vehicle.model, locale);
+  return `${brand} ${model}`.trim();
+}

package/src/resolve.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Déclarations typées de la résolution de thèmes (implémentation : resolve.js).
+ * Reflet exact de l'API publique du module.
+ */
+
+export type ResolveOptions = {
+  assetsRoot?: string;
+};
+
+/** Id du thème d'images de référence (pack par défaut). */
+export const DEFAULT_IMAGE_THEME: string;
+/** Fichier d'image de repli universel. */
+export const NO_IMAGE: string;
+
+/** Normalise un id de thème (minuscules, [a-z0-9_-]), tombe sur le thème par défaut. */
+export function normalizeThemeId(raw: unknown): string;
+
+/**
+ * Meilleure image : thème → gta-artwork → no_image.
+ * Sans assets embarqués, renvoie un chemin URL-able `items/{thème}/{fichier}`.
+ */
+export function resolveThemedImage(
+  imageFile: string | null | undefined,
+  themeId?: string | null | undefined,
+  opts?: ResolveOptions
+): string;
+
+/** Items exclusifs d'un thème (non utilisés par l'API publique directement). */
+export function _clearExistsCache(): void;

package/src/resolve.js

@@ -0,0 +1,162 @@
+/**
+ * Résolution des thèmes (packs d'images + renommages + items exclusifs).
+ * Portage du comportement du bot Amity :
+ *   - un thème se greffe sur le catalogue sans le modifier ;
+ *   - les remplacements n'appliquent que les champs présents ;
+ *   - l'image retombe sur le thème de référence (gta-artwork), puis no_image.
+ *
+ * Source de vérité des thèmes disponibles : themes/themes.json (le registre).
+ */
+
+/** Id du thème d'images de référence (pack par défaut). */
+export const DEFAULT_IMAGE_THEME = 'gta-artwork';
+
+export const NO_IMAGE = 'no_image.png';
+
+import { existsSync } from 'node:fs';
+
+const existsCache = new Map();
+
+function fileExists(fsPath) {
+  if (existsCache.has(fsPath)) return existsCache.get(fsPath);
+  const ok = existsSync(fsPath);
+  existsCache.set(fsPath, ok);
+  return ok;
+}
+
+/** Libère le cache d'existence de fichiers (rechargement à chaud). */
+export function _clearExistsCache() {
+  existsCache.clear();
+  rootValidCache.clear();
+}
+
+/**
+ * Renvoie le meilleur chemin d'image : thème → gta-artwork → no_image.
+ *
+ * - `assetsRoot` fourni et valide (le dossier items/gta-artwork y existe) : contrôle
+ *   fichier par fichier, no_image en ultime recours.
+ * - assets NON embarqués (package sans assets) : renvoie un chemin relatif
+ *   « URL-able » `items/{theme}/{file}` que le consommateur mappe sur son CDN.
+ */
+export function resolveThemedImage(imageFile, themeId, { assetsRoot } = {}) {
+  const safeImage = (imageFile || '').trim() || NO_IMAGE;
+  const theme = normalizeThemeId(themeId);
+
+  const candidate = (t) =>
+    assetsRoot ? `${assetsRoot}/items/${t}/${safeImage}` : `assets/items/${t}/${safeImage}`;
+
+  const assetsValid =
+    !assetsRoot || assetRootHasPacks(assetsRoot);
+
+  if (theme && theme !== DEFAULT_IMAGE_THEME) {
+    const themed = candidate(theme);
+    if (assetsValid && fileExists(themed)) return themed;
+  }
+
+  const base = candidate(DEFAULT_IMAGE_THEME);
+  if (assetsValid && fileExists(base)) return base;
+
+  if (!assetsValid) {
+    const t = theme && theme !== DEFAULT_IMAGE_THEME ? theme : DEFAULT_IMAGE_THEME;
+    return `items/${t}/${safeImage}`;
+  }
+
+  return assetsRoot ? `${assetsRoot}/no_image.png` : `assets/items/${NO_IMAGE}`;
+}
+
+let rootValidCache = new Map();
+
+function assetRootHasPacks(assetsRoot) {
+  if (rootValidCache.has(assetsRoot)) return rootValidCache.get(assetsRoot);
+  const ok = existsSync(`${assetsRoot}/items/${DEFAULT_IMAGE_THEME}`);
+  rootValidCache.set(assetsRoot, ok);
+  return ok;
+}
+
+/** Normalise un id de thème (minuscules, [a-z0-9_-]). */
+export function normalizeThemeId(raw) {
+  if (typeof raw !== 'string') return DEFAULT_IMAGE_THEME;
+  const normalized = raw.trim().toLowerCase().replace(/[^a-z0-9_-]/g, '');
+  return normalized || DEFAULT_IMAGE_THEME;
+}
+
+/** Construit un item exclusif complet depuis une entrée de thème. */
+export function buildExclusiveItem(entry) {
+  if (!entry || typeof entry.id !== 'string' || !entry.id.trim()) return null;
+  if (!entry.name || typeof entry.name !== 'object') return null;
+  if (!entry.image || typeof entry.image !== 'string') return null;
+  if (!Number.isFinite(entry.weight)) return null;
+
+  return {
+    id: entry.id,
+    name: entry.name,
+    description: entry.description || { fr: '', en: '' },
+    image: entry.image,
+    emoji: entry.emoji || '',
+    weight: entry.weight,
+    food: entry.food ?? 0,
+    thirst: entry.thirst ?? 0,
+    drug: entry.drug ?? null,
+    stackable: entry.stackable ?? true,
+    usable: entry.usable ?? false,
+    tags: entry.tags || [],
+    metadata: entry.metadata || {},
+    customProperties: entry.customProperties || {},
+  };
+}
+
+/** Applique un override sur un item existant (seuls les champs présents remplacent). */
+export function applyOverride(baseItem, override) {
+  if (!baseItem || !override) return baseItem;
+  const merged = { ...baseItem };
+
+  for (const field of [
+    'name', 'description', 'image', 'emoji', 'weight', 'food', 'thirst',
+    'drug', 'stackable', 'usable', 'tags', 'customProperties',
+  ]) {
+    if (override[field] !== undefined) merged[field] = override[field];
+  }
+  return merged;
+}
+
+/**
+ * Résout un item complet pour un thème donné :
+ *   - item du catalogue + override du thème (fusion) ;
+ *   - ou item exclusif du thème si l'id n'existe pas dans le catalogue.
+ * Retourne null si introuvable.
+ */
+export function resolveThemedItem(baseItems, itemId, theme) {
+  const safeId = (itemId || '').trim();
+  if (!safeId) return null;
+
+  // 1. item exclusif du thème ?
+  // 2. override sur un item du catalogue ?
+  const themeEntries = theme?.overrides || [];
+  const themeExclusives = theme?.exclusiveItems || [];
+
+  if (baseItems && Array.isArray(baseItems)) {
+    // Items uniquement dans le thème : non remplacés par les overrides.
+    for (const entry of themeExclusives) {
+      if (entry.id === safeId) return buildExclusiveItem(entry);
+    }
+  }
+
+  const base = Array.isArray(baseItems)
+    ? baseItems.find((i) => i?.id === safeId) || null
+    : null;
+
+  const override = themeEntries.find((e) => e?.id === safeId) || null;
+
+  if (base && override) return applyOverride(base, override);
+  if (base) return base;
+  return null;
+}
+
+/** Ids d'items effectivement disponibles dans un thème. */
+export function listThemeItemIds(theme) {
+  const ids = new Set((theme?.overrides || []).map((e) => e?.id));
+  for (const e of theme?.exclusiveItems || []) {
+    ids.add(e?.id);
+  }
+  return Array.from(ids);
+}

package/themes/dayz.json

@@ -0,0 +1,56 @@
+{
+  "$schema": "../catalog/schemas/theme.schema.json",
+  "$comment": "Thème DayZ (post-apo). Migré depuis item-themes/dayz.json du bot + names.json. Les ids money_* sont des items virtuels (argent propre/sale/faux) gérés en code — déclarés dans virtualIds. Les images non présentes dans assets/items/dayz/ retombent automatiquement sur le pack gta-artwork.",
+  "virtualIds": ["money_clean", "money_dirty", "money_fake"],
+  "overrides": [
+    {
+      "id": "burger",
+      "name": { "fr": "Conserve DayZ", "en": "DayZ Canned Food" },
+      "image": "burger.png"
+    },
+    {
+      "id": "small_water_bottle",
+      "name": { "fr": "Gourde usée", "en": "Worn Canteen" },
+      "image": "small_water_bottle.png"
+    },
+    {
+      "id": "money_clean",
+      "name": { "fr": "Billets", "en": "Bills" },
+      "image": "money.png"
+    },
+    {
+      "id": "money_dirty",
+      "name": { "fr": "Argent contaminé", "en": "Contaminated Cash" },
+      "image": "dirty_money.png"
+    },
+    {
+      "id": "money_fake",
+      "name": { "fr": "Billets contrefaits", "en": "Counterfeit Bills" },
+      "image": "fake_money.png"
+    }
+  ],
+  "exclusiveItems": [
+    {
+      "id": "aks74u",
+      "name": { "fr": "AKS-74U", "en": "AKS-74U" },
+      "description": { "fr": "Un fusil d'assaut soviétique compact.", "en": "A compact Soviet assault rifle." },
+      "image": "AKS74U.png",
+      "emoji": "🔫",
+      "weight": 3500,
+      "usable": true,
+      "stackable": false,
+      "metadata": { "irl": { "model": "Krinkov AKS-74U", "caliber": "5,45 × 39 mm" } },
+      "tags": ["weapon"]
+    },
+    {
+      "id": "dayz_bandage",
+      "name": { "fr": "Bandage improvisé", "en": "Improvised Bandage" },
+      "description": { "fr": "Une bande de tissu pour soigner les blessures.", "en": "A strip of cloth to treat wounds." },
+      "image": "bandage.png",
+      "emoji": "🩹",
+      "weight": 60,
+      "usable": true,
+      "stackable": true
+    }
+  ]
+}

package/themes/gta-artwork.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "../catalog/schemas/theme.schema.json",
+  "$comment": "Thème GTA V Artwork : pack d'images de référence. EXEMPLE DE RENOMMAGE — le catalogue porte le nom canonique/IRL (metadata.irl donne l'identité réelle), ce thème applique le nom que GTA V donne à l'objet. Chaque item du catalogue dont metadata.irl est rempli peut être renommé ici.",
+  "overrides": [
+    {
+      "id": "weapon_beretta",
+      "name": { "fr": "Pistol", "en": "Pistol" },
+      "description": { "fr": "Un pistolet semi-automatique fiable.", "en": "A reliable semi-automatic pistol." }
+    },
+    {
+      "id": "weapon_ak47",
+      "name": { "fr": "Rifle d'assaut", "en": "Assault Rifle" }
+    }
+  ],
+  "exclusiveItems": []
+}