gatsby-core-theme 44.15.2 → 44.16.0

package/CHANGELOG.md

@@ -1,3 +1,39 @@
+# [44.16.0](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/compare/v44.15.3...v44.16.0) (2026-02-26)
+
+
+### Bug Fixes
+
+* guard toplists access in processTopListModule to prevent crash on undefined ([0fd53b3](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/0fd53b3f96cede6120838777707ae0a993284b43))
+* include operators on game toplist ([fcaae16](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/fcaae16634f3dc8879f2818eb8e50fb14451a495))
+* pass single operator for game toplist item ([181f031](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/181f031276fa7b16d3d58b8b240f754901f6270f))
+* process game top list ([c7f494a](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/c7f494aefc29bb82c6c98dc013bdfe58a9befa9d))
+
+
+### Code Refactoring
+
+* extract toplist helpers from modules.mjs into helpers/toplist.mjs ([3727ed8](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/3727ed863baa2cfaccdfecba8750ebc3dbbc19d8))
+* process top list ([e2c4589](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/e2c45898b74b1412125464b4c230aa1be060ed32))
+
+
+* Merge branch 'en-379-game-toplist' into 'master' ([5f8672c](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/5f8672cbcba7853bee36fa6aab68e0a41d2152f0))
+* Merge remote-tracking branch 'origin' into en-379-game-toplist ([f6b2f05](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/f6b2f05c9c598f687af74c420d6ccee96eec3582))
+
+
+### Features
+
+* process game toplist ([2f7944f](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/2f7944f612dd3e970726c0a5e82e5027e9360922))
+
+## [44.15.3](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/compare/v44.15.2...v44.15.3) (2026-02-26)
+
+
+### Bug Fixes
+
+* add also meutimao ([cbe7293](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/cbe729308e6a84760e7f3b93213600f1a8c83968))
+* improve the tracker type and make possible to edit for specific sites ([a3f2e17](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/a3f2e1776c8c1ce14a05fba06f375ad51117bdce))
+
+
+* Merge branch 'tracker-type-built' into 'master' ([790c754](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/commit/790c7543bbd2532f5ab1cac6fd8d6f34b38f8461))
+
 ## [44.15.2](https://gitlab.com/g2m-gentoo/team-floyd/themes/gatsby-themes/compare/v44.15.1...v44.15.2) (2026-02-26)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gatsby-core-theme",
-  "version": "44.15.2",
+  "version": "44.16.0",
   "description": "Gatsby Theme NPM Package",
   "author": "",
   "license": "ISC",

package/src/constants/trackerTypePerSite.mjs

@@ -0,0 +1,13 @@
+export default {
+    'odia.ig.com.br': {
+        'casino': ['type', "[cassino]"],
+        'sportsbook': ['type', "[esportes]"],
+    },
+    'meutimao.com.br': {
+        'casino': ['type', "[cassino]"],
+        'sportsbook': ['type', "[esportes]"],
+    },
+    default: {
+        casino: ['type,', ''],
+    },
+};

package/src/helpers/generators.mjs

@@ -1,4 +1,5 @@
 import generatorsConstant from "../constants/generators.mjs";
+import trackerTypePerSite from "../constants/trackerTypePerSite.mjs";
 
 export function generateTrackerLink(operator, trackerType, provider = false) {
   let defaultTrackerFormat = provider
@@ -8,11 +9,14 @@ export function generateTrackerLink(operator, trackerType, provider = false) {
     ? process.env.PROVIDER_TRACKER_LINK_FORMAT_NON_MAIN
     : process.env.TRACKER_LINK_FORMAT_NON_MAIN;
 
+  const replaceTrackerFormat = trackerTypePerSite[process.env.GATSBY_SITE_NAME] || trackerTypePerSite.default;
+
   if (defaultTrackerFormat && trackerFormat) {
-    if (operator.type === "casino") {
-      defaultTrackerFormat = defaultTrackerFormat.replace("type,", "");
-      trackerFormat = trackerFormat.replace("type,", "");
+    if(replaceTrackerFormat?.[operator?.type]){
+      defaultTrackerFormat = defaultTrackerFormat.replace(replaceTrackerFormat[operator.type][0], replaceTrackerFormat[operator.type][1]);
+      trackerFormat = trackerFormat.replace(replaceTrackerFormat[operator.type][0], replaceTrackerFormat[operator.type][1]);
     }
+
     const linkFormatArray =
       trackerType === "main"
         ? defaultTrackerFormat.split(",")

package/src/helpers/generators.test.js

@@ -31,6 +31,48 @@ describe("Generate Tracker Link Helper", () => {
     );
     expect(trackerLink).toEqual("/no/visit/bet365");
   });
+  test("sportsbook type is shown as-is for default site (non_main)", () => {
+    const trackerLink = generateTrackerLink(
+      { type: "sportsbook", short_name: "bet365" },
+      "non_main"
+    );
+    expect(trackerLink).toEqual("/no/visit/bet365/sportsbook/non_main");
+  });
+});
+
+describe("Generate Tracker Link Helper - Site Type Translations", () => {
+  const originalSiteName = process.env.GATSBY_SITE_NAME;
+
+  afterEach(() => {
+    process.env.GATSBY_SITE_NAME = originalSiteName;
+  });
+
+  test("casino type is translated for translated site (non_main)", () => {
+    process.env.GATSBY_SITE_NAME = "odia.ig.com.br";
+    const trackerLink = generateTrackerLink(
+      { type: "casino", short_name: "bet365" },
+      "non_main"
+    );
+    expect(trackerLink).toEqual("/no/visit/bet365/cassino/non_main");
+  });
+
+  test("sportsbook type is translated for translated site (non_main)", () => {
+    process.env.GATSBY_SITE_NAME = "odia.ig.com.br";
+    const trackerLink = generateTrackerLink(
+      { type: "sportsbook", short_name: "bet365" },
+      "non_main"
+    );
+    expect(trackerLink).toEqual("/no/visit/bet365/esportes/non_main");
+  });
+
+  test("main tracker link is unaffected by type translation", () => {
+    process.env.GATSBY_SITE_NAME = "odia.ig.com.br";
+    const trackerLink = generateTrackerLink(
+      { type: "casino", short_name: "bet365" },
+      "main"
+    );
+    expect(trackerLink).toEqual("/no/visit/bet365");
+  });
 });
 
 describe("Generate Placeholders String", () => {

package/src/helpers/toplist.mjs

@@ -0,0 +1,142 @@
+/* eslint-disable camelcase */
+/* eslint-disable import/no-extraneous-dependencies */
+import loadash from "lodash/index.js";
+import { stripDomainAndLeadingSlash } from "./path.mjs";
+import { sanitizeOperatorData } from "../resolver/operators.mjs";
+import { sanitizegameData } from "../resolver/games.mjs";
+import buildToplistFilter from "../resolver/build-toplist-filter.mjs";
+
+const { cloneDeep } = loadash;
+
+/**
+ * @param {Object} item - Raw toplist item from DMS (operator or game)
+ * @param {Object|null} itemRelation - Resolved relation data for the item
+ * @param {Array<Object>} itemPages - Pages matching this relation
+ * @param {Object} ctx - Shared processing context
+ * @param {boolean} ctx.filterEnabled - Whether filter mode is active
+ * @param {Object} ctx.filters - Filter accumulator object
+ * @param {Object} ctx.data - Full relations data (payment methods, etc.)
+ * @param {Object|null} ctx.toplists - Toplists lookup map
+ * @param {string|undefined} ctx.toplistLabel - Label from the parent toplist item
+ * @returns {Object|null} Sanitized toplist item or null if no relation
+ */
+export function processToplistItem(item, itemRelation, itemPages, ctx) {
+  if (!itemRelation) {
+    return null;
+  }
+
+  itemRelation.ribbons =
+    item.ribbon_ids && item.ribbon_ids.length === 0
+      ? itemRelation.ribbons
+      : item.ribbon_ids;
+
+  itemRelation.selling_points =
+    item.selling_points && item.selling_points.length === 0
+      ? itemRelation.selling_points
+      : item.selling_points;
+
+  itemRelation.updated_at = item.updated_at;
+  itemRelation.toplist_bonus = item.bonus_name;
+  itemRelation.toplist_item_tracker_name = item.tracker_name;
+
+  const reviewLink =
+    process.env.DMS_REVIEW_LINKS_ENABLED === "true"
+      ? stripDomainAndLeadingSlash(itemRelation?.review_link)
+      : itemPages[0]?.path;
+
+  const authorTitle = itemPages[0]?.author?.author_title;
+  const clone = item.game_id
+    ? sanitizegameData(cloneDeep(itemRelation), itemPages, ["operators"])
+    : sanitizeOperatorData(
+        cloneDeep(itemRelation),
+        itemPages,
+        ctx.data,
+        ctx.toplistLabel
+      );
+  const socialAuthorLinks = [
+    "facebook_profile",
+    "twitter_profile",
+    "instagram_profile",
+    "linkedin_profile",
+  ];
+
+  if (ctx.filterEnabled) {
+    buildToplistFilter(ctx.filters, clone);
+  }
+
+  return Object.assign(clone, {
+    review_link: reviewLink,
+    author_title: authorTitle,
+    author_same_as:
+      itemPages[0]?.author &&
+      socialAuthorLinks
+        .map((socialLink) => itemPages[0]?.author?.[socialLink])
+        .filter((socialLink) => socialLink),
+  });
+}
+
+/**
+ * @param {Object} item - Raw operator toplist item with operator_id
+ * @param {Object} ctx - Shared processing context
+ * @param {Object} ctx.relations - All relations keyed by type (operator, game, etc.)
+ * @param {Object} ctx.pages - Pages grouped by type
+ * @param {string|undefined} ctx.type - Operator type filter (e.g. "casino")
+ * @param {string} ctx.market - Market short code
+ * @param {boolean} ctx.filterEnabled
+ * @param {Object} ctx.filters
+ * @param {Object} ctx.data
+ * @param {Object|null} ctx.toplists
+ * @param {string|undefined} ctx.toplistLabel
+ * @returns {Object|null} Sanitized operator item or null
+ */
+export function processOperatorToplist(item, ctx) {
+  const operatorRelation = cloneDeep(
+    Object.values(ctx.relations.operator).find(
+      (operator) =>
+        operator.operator_id === (item.operator_id || item.id) &&
+        operator.market === ctx.market &&
+        (ctx.type ? ctx.type === operator.type : true)
+    )
+  );
+
+  const operatorPage =
+    ctx.pages?.operator && operatorRelation
+      ? ctx.pages.operator.filter(
+          (page) =>
+            page.relation?.operator_id === operatorRelation.operator_id &&
+            page.relation?.type === operatorRelation.type
+        )
+      : [];
+
+  return processToplistItem(item, operatorRelation, operatorPage, ctx);
+}
+
+/**
+ * @param {Object} item - Raw game toplist item with game_id and operators array
+ * @param {Object} ctx - Same context as processOperatorToplist
+ * @returns {Object|null} Sanitized game item or null
+ */
+export function processGameToplist(item, ctx) {
+  const relation = cloneDeep(
+    Object.values(ctx.relations.game).find(
+      (game) => game.game_id === item.game_id
+    )
+  );
+  const gameOperators = (item.operators ?? [])
+    .map((operator) => processOperatorToplist(operator, ctx))
+    .filter(Boolean);
+  const gamePage = ctx.pages?.game
+    ? ctx.pages.game.filter(
+        (page) =>
+          page.relation?.game_id === relation?.game_id &&
+          page.relation?.market === ctx.market
+      )
+    : [];
+
+  return processToplistItem(
+    item,
+    { ...relation, operators: gameOperators?.[0] },
+    gamePage,
+    ctx
+  );
+}

package/src/helpers/toplist.test.js

@@ -0,0 +1,288 @@
+import loadash from "lodash/index.js";
+import {
+  processToplistItem,
+  processOperatorToplist,
+  processGameToplist,
+} from "./toplist.mjs";
+import { relationData } from "~tests/factories/modules/toplist.factory";
+
+const { cloneDeep } = loadash;
+
+jest.mock("../resolver/build-toplist-filter.mjs", () => ({
+  __esModule: true,
+  default: jest.fn(),
+}));
+// eslint-disable-next-line import/first
+import buildToplistFilter from "../resolver/build-toplist-filter.mjs";
+
+describe("processToplistItem", () => {
+  const baseCtx = {
+    filterEnabled: false,
+    filters: {},
+    data: relationData,
+    toplists: null,
+    toplistLabel: undefined,
+  };
+
+  test("returns null when itemRelation is null", () => {
+    const result = processToplistItem({ operator_id: 1 }, null, [], baseCtx);
+    expect(result).toBeNull();
+  });
+
+  test("returns null when itemRelation is undefined", () => {
+    const result = processToplistItem(
+      { operator_id: 1 },
+      undefined,
+      [],
+      baseCtx
+    );
+    expect(result).toBeNull();
+  });
+
+  test("returns sanitized operator item with correct fields", () => {
+    const item = {
+      operator_id: 6342,
+      selling_points: ["classicslots", "bitcoin", "bingo"],
+      updated_at: "2025-01-14 11:04:49",
+      bonus_name: "Welcome Bonus",
+      tracker_name: "main_tracker",
+    };
+    const itemRelation = cloneDeep(relationData.operator[6342]);
+    const pages = [{ path: "en/slotum", author: { author_title: "John" } }];
+
+    const result = processToplistItem(item, itemRelation, pages, baseCtx);
+
+    expect(result).not.toBeNull();
+    expect(result.review_link).toBe("en/slotum");
+    expect(result.author_title).toBe("John");
+    expect(result.short_name).toBe("slotum");
+  });
+
+  test("preserves original ribbons when ribbon_ids is empty array", () => {
+    const originalRibbons = [1, 2, 3];
+    const item = {
+      operator_id: 6342,
+      ribbon_ids: [],
+      updated_at: "2025-01-14",
+    };
+    const itemRelation = cloneDeep(relationData.operator[6342]);
+    itemRelation.ribbons = originalRibbons;
+
+    processToplistItem(item, itemRelation, [], baseCtx);
+
+    expect(itemRelation.ribbons).toEqual(originalRibbons);
+  });
+
+  test("overrides ribbons when ribbon_ids has values", () => {
+    const item = {
+      operator_id: 6342,
+      ribbon_ids: [10, 20],
+      updated_at: "2025-01-14",
+    };
+    const itemRelation = cloneDeep(relationData.operator[6342]);
+    itemRelation.ribbons = [1, 2, 3];
+
+    processToplistItem(item, itemRelation, [], baseCtx);
+
+    expect(itemRelation.ribbons).toEqual([10, 20]);
+  });
+
+  test("preserves original selling_points when selling_points is empty array", () => {
+    const originalSP = ["point1", "point2"];
+    const item = {
+      operator_id: 6342,
+      selling_points: [],
+      updated_at: "2025-01-14",
+    };
+    const itemRelation = cloneDeep(relationData.operator[6342]);
+    itemRelation.selling_points = originalSP;
+
+    processToplistItem(item, itemRelation, [], baseCtx);
+
+    expect(itemRelation.selling_points).toEqual(originalSP);
+  });
+
+  test("calls buildToplistFilter when filterEnabled is true", () => {
+    buildToplistFilter.mockClear();
+    const ctx = { ...baseCtx, filterEnabled: true, filters: { test: true } };
+    const item = {
+      operator_id: 6342,
+      selling_points: ["a"],
+      updated_at: "2025-01-14",
+    };
+    const itemRelation = cloneDeep(relationData.operator[6342]);
+
+    processToplistItem(item, itemRelation, [], ctx);
+
+    expect(buildToplistFilter).toHaveBeenCalledTimes(1);
+    expect(buildToplistFilter).toHaveBeenCalledWith(
+      ctx.filters,
+      expect.any(Object)
+    );
+  });
+
+  test("does not call buildToplistFilter when filterEnabled is false", () => {
+    buildToplistFilter.mockClear();
+    const item = {
+      operator_id: 6342,
+      selling_points: ["a"],
+      updated_at: "2025-01-14",
+    };
+    const itemRelation = cloneDeep(relationData.operator[6342]);
+
+    processToplistItem(item, itemRelation, [], baseCtx);
+
+    expect(buildToplistFilter).not.toHaveBeenCalled();
+  });
+});
+
+describe("processOperatorToplist", () => {
+  const baseCtx = {
+    relations: relationData,
+    pages: undefined,
+    type: "casino",
+    market: undefined,
+    filterEnabled: false,
+    filters: {},
+    data: relationData,
+    toplists: null,
+    toplistLabel: undefined,
+  };
+
+  test("finds correct operator relation by operator_id and type", () => {
+    const item = {
+      operator_id: 6342,
+      selling_points: ["a", "b", "c"],
+      updated_at: "2025-01-14",
+    };
+
+    const result = processOperatorToplist(item, baseCtx);
+
+    expect(result).not.toBeNull();
+    expect(result.short_name).toBe("slotum");
+  });
+
+  test("returns null when no matching operator relation exists", () => {
+    const item = {
+      operator_id: 99999,
+      updated_at: "2025-01-14",
+    };
+
+    const result = processOperatorToplist(item, baseCtx);
+
+    expect(result).toBeNull();
+  });
+
+  test("falls back to item.id when item.operator_id is missing", () => {
+    const item = {
+      id: 6342,
+      selling_points: ["a"],
+      updated_at: "2025-01-14",
+    };
+
+    const result = processOperatorToplist(item, baseCtx);
+
+    expect(result).not.toBeNull();
+    expect(result.short_name).toBe("slotum");
+  });
+
+  test("matches operator pages by operator_id and type", () => {
+    const ctx = {
+      ...baseCtx,
+      pages: {
+        operator: [
+          {
+            relation_id: 6342,
+            path: "en/slotum",
+            relation: { operator_id: 6342, type: "casino" },
+            author: { author_title: "Editor" },
+          },
+        ],
+      },
+    };
+    const item = {
+      operator_id: 6342,
+      selling_points: ["a"],
+      updated_at: "2025-01-14",
+    };
+
+    const result = processOperatorToplist(item, ctx);
+
+    expect(result.review_link).toBe("en/slotum");
+    expect(result.author_title).toBe("Editor");
+  });
+});
+
+describe("processGameToplist", () => {
+  const gameRelations = {
+    ...relationData,
+    game: {
+      100: {
+        game_id: 100,
+        name: "Test Slot",
+        short_name: "test-slot",
+        market: "en_za",
+      },
+    },
+  };
+
+  const baseCtx = {
+    relations: gameRelations,
+    pages: undefined,
+    type: "casino",
+    market: "en_za",
+    filterEnabled: false,
+    filters: {},
+    data: gameRelations,
+    toplists: null,
+    toplistLabel: undefined,
+  };
+
+  test("processes game operators through processOperatorToplist", () => {
+    const item = {
+      game_id: 100,
+      operators: [
+        { operator_id: 6342, selling_points: ["a"], updated_at: "2025-01-14" },
+      ],
+      updated_at: "2025-01-14",
+    };
+
+    const result = processGameToplist(item, baseCtx);
+
+    expect(result).not.toBeNull();
+  });
+
+  test("returns object with undefined fields when game relation not found", () => {
+    const item = {
+      game_id: 99999,
+      operators: [],
+      updated_at: "2025-01-14",
+    };
+
+    const result = processGameToplist(item, baseCtx);
+
+    // When relation is not found, the spread of undefined still creates an object
+    // so processToplistItem receives a non-null itemRelation
+    expect(result).toBeDefined();
+    expect(result.operators).toBeUndefined();
+  });
+
+  test("attaches first processed operator to the game relation", () => {
+    const item = {
+      game_id: 100,
+      operators: [
+        { operator_id: 6342, selling_points: ["a"], updated_at: "2025-01-14" },
+        { operator_id: 6343, selling_points: ["b"], updated_at: "2025-01-14" },
+      ],
+      updated_at: "2025-01-14",
+    };
+
+    const result = processGameToplist(item, baseCtx);
+
+    expect(result).not.toBeNull();
+    // The first processed operator should be attached as the operators field
+    if (result.operators) {
+      expect(result.operators.short_name).toBeDefined();
+    }
+  });
+});

package/src/helpers/tracker.mjs

@@ -2,7 +2,7 @@
 /* eslint-disable no-underscore-dangle */
 import { generateTrackerLink } from "./generators.mjs";
 import { stripSuffixSlash } from "./strings.mjs";
-import { getCookie } from "./cookies.js";
+import { getCookie } from "./cookies.mjs";
 
 export function getTrackerName(operator, page, path) {
   const trackerLinks = operator ? Object.keys(operator.links) : [];

package/src/resolver/modules.mjs

@@ -4,7 +4,7 @@
 /* eslint-disable import/no-extraneous-dependencies */
 import loadash from "lodash/index.js";
 import { generatePlaceholderString } from "../helpers/generators.mjs";
-import { stripDomainAndLeadingSlash } from "../helpers/path.mjs";
+import { processOperatorToplist, processGameToplist } from "../helpers/toplist.mjs";
 import {
   clonePageForCards,
   groupBy,
@@ -19,7 +19,6 @@ import {
   getModuleTitle,
   trailingSlash,
 } from "../helpers/getters.mjs";
-import buildToplistFilter from "./build-toplist-filter.mjs";
 
 const pagesGroupedByTemplateId = [];
 const cardItems = {};
@@ -375,100 +374,56 @@ export function processTopListModule(
     payout_rate: {},
     licenses: {},
   };
-
   module.items = module.items.map((listItem) => {
     const { type } = listItem;
     const showLoadMore = +listItem.show_load_more;
     const itemsCount = +listItem.num_items_initial_load;
-    if (listItem.id && toplists && toplists[listItem.id.toString()]) {
-      listItem.market = toplists[listItem.id].market?.short_code;
-      listItem.items = toplists[listItem.id].items;
-      listItem.one_liner = toplists[listItem.id].one_liner;
-      listItem.tracker = toplists[listItem.id].tracker;
+    const toplistItem = toplists && listItem.id
+      ? toplists[listItem.id.toString()] ||
+        toplists[`g_${listItem.id.toString()}`]
+      : undefined;
+    if (toplistItem) {
+      listItem.market = toplistItem.market?.short_code;
+      listItem.items = toplistItem.items;
+      listItem.one_liner = toplistItem.one_liner;
+      listItem.tracker = toplistItem.tracker;
     }
-
     if (!showLoadMore && itemsCount) {
       listItem.items = listItem.items?.slice(0, itemsCount);
     }
+    const ctx = {
+      relations,
+      pages,
+      type,
+      market: listItem.market,
+      filterEnabled,
+      filters,
+      data,
+      toplists,
+      toplistLabel: toplists && toplistItem?.label,
+    };
 
+    // build top list
     listItem.items = listItem.items
       ? listItem.items
-          .map((item) => {
-            const operatorRelation = cloneDeep(
+          .filter(
+            (item) =>
               Object.values(relations.operator).find(
                 (operator) =>
                   operator.operator_id === item.operator_id &&
                   operator.market === listItem.market &&
                   type === operator.type
+              ) ||
+              Object.values(relations.game).find(
+                (game) => game.game_id === item.game_id
               )
-            );
-
-            // If we can't find a matching operator relation, skip this toplist item
-            if (!operatorRelation) {
-              return null;
-            }
-
-            operatorRelation.ribbons =
-              item.ribbon_ids && item.ribbon_ids.length === 0
-                ? operatorRelation.ribbons
-                : item.ribbon_ids;
-
-            operatorRelation.selling_points =
-              item.selling_points && item.selling_points.length === 0
-                ? operatorRelation.selling_points
-                : item.selling_points;
-
-            operatorRelation.updated_at = item.updated_at;
-            operatorRelation.toplist_bonus = item.bonus_name;
-            operatorRelation.toplist_item_tracker_name = item.tracker_name;
-
-            const operatorPage =
-              pages && pages.operator && operatorRelation
-                ? pages.operator.filter(
-                    (page) =>
-                      page.relation &&
-                      page.relation.operator_id ===
-                        operatorRelation.operator_id &&
-                      page.relation.type === operatorRelation.type
-                  )
-                : [];
-
-            const reviewLink =
-              process.env.DMS_REVIEW_LINKS_ENABLED === "true"
-                ? stripDomainAndLeadingSlash(operatorRelation?.review_link)
-                : operatorPage[0]?.path;
-
-            const authorTitle =
-              operatorPage[0] && operatorPage[0]?.author?.author_title;
-
-            const clone = sanitizeOperatorData(
-              cloneDeep(operatorRelation),
-              operatorPage,
-              data,
-              toplists && toplists[listItem.id].label
-            );
-
-            const socialAuthorLinks = [
-              "facebook_profile",
-              "twitter_profile",
-              "instagram_profile",
-              "linkedin_profile",
-            ];
-            if (filterEnabled) {
-              buildToplistFilter(filters, clone);
-            }
-            return Object.assign(clone, {
-              review_link: reviewLink,
-              author_title: authorTitle,
-              author_same_as:
-                operatorPage[0] &&
-                operatorPage[0]?.author &&
-                socialAuthorLinks
-                  .map((socialLink) => operatorPage[0]?.author?.[socialLink])
-                  .filter((socialLink) => socialLink),
-            });
+          )
+          .map((item) => {
+            if (item.operator_id) return processOperatorToplist(item, ctx);
+            if (item.game_id) return processGameToplist(item, ctx);
+            return null;
           })
-          .filter((item) => item)
+          .filter(Boolean)
       : [];
     const latestItems = listItem.items
       .map((toplist) => ({
@@ -477,7 +432,6 @@ export function processTopListModule(
       }))
       .sort((a, b) => b.updated_at - a.updated_at)
       .slice(0, 3);
-
     const formattedLatestItems = latestItems
       .map((item) => item.name)
       .reduce((acc, curr, index, array) => {
@@ -626,9 +580,13 @@ export function processAnchor(module = {}, relationData, translations) {
         relationData
       );
       anchor.label = generatedLabel;
-      anchor.slug = generatePlaceholderString(anchor?.slug?.trim(), translations, relationData);
+      anchor.slug = generatePlaceholderString(
+        anchor?.slug?.trim(),
+        translations,
+        relationData
+      );
     });
-    
+
   return module;
 }