@flesh-and-blood/search 3.9.13 → 4.0.0

package/dist/metaFilters.js

@@ -0,0 +1,395 @@
+import { Format, Hero, Talent } from "@flesh-and-blood/types";
+import { PUNCTUATION } from "./constants";
+var FilterProperty = /* @__PURE__ */ ((FilterProperty2) => {
+  FilterProperty2["BannedFormats"] = "bannedFormats";
+  FilterProperty2["LegalFormats"] = "legalFormats";
+  FilterProperty2["LegalHeroes"] = "legalHeroes";
+  return FilterProperty2;
+})(FilterProperty || {});
+const oneToFifty = Array.from(Array(50).keys()).map((value) => `${value}`);
+const nicknameFormatMappings = [
+  {
+    format: Format.ClassicConstructed,
+    nicknames: ["cc", "classic"]
+  },
+  {
+    format: Format.LivingLegend,
+    nicknames: [
+      "cc ll",
+      "classic constructed ll",
+      "ll cc",
+      "ll",
+      "living legend"
+    ]
+  },
+  {
+    format: Format.SilverAge,
+    nicknames: ["sage"]
+  },
+  {
+    format: Format.GoldenAge,
+    nicknames: ["gage"]
+  },
+  {
+    format: Format.UltimatePitFight,
+    nicknames: ["upf"]
+  }
+];
+const formatMappings = Object.values(Format).map((format) => {
+  const withNicknames = nicknameFormatMappings.find(
+    ({ format: nicknameFormat }) => nicknameFormat === format
+  );
+  const cleanFormat = format.toLowerCase().replaceAll(PUNCTUATION, "");
+  return withNicknames ? { ...withNicknames, format: cleanFormat } : { format: cleanFormat };
+});
+const nicknameHeroMappings = [
+  {
+    hero: Hero.DataDoll,
+    nicknames: ["data", "datadoll"]
+  },
+  {
+    hero: Hero.Dorinthea,
+    nicknames: ["dori"]
+  },
+  {
+    hero: Hero.Genis,
+    nicknames: ["genis"]
+  },
+  {
+    hero: Hero.GravyBones,
+    nicknames: ["gravy"]
+  },
+  {
+    hero: Hero.Iyslander,
+    nicknames: ["islander"]
+  }
+];
+const heroMappings = Object.values(
+  Hero
+).map((hero) => {
+  const withNicknames = nicknameHeroMappings.find(
+    ({ hero: nicknameHero }) => nicknameHero === hero
+  );
+  const cleanHero = hero.toLowerCase().replaceAll(PUNCTUATION, "");
+  return withNicknames ? { ...withNicknames, hero: cleanHero } : { hero: cleanHero };
+});
+const rankedRarity = [
+  "common",
+  "rare",
+  "super rare",
+  "majestic",
+  "legendary",
+  "fabled"
+];
+const getRarityFilter = (values, modifier, isExcluded, isOptional) => {
+  const rarities = [];
+  if (!modifier) {
+    rarities.push(...values);
+  } else {
+    for (const value of values) {
+      switch (modifier) {
+        case ">=":
+          let start = false;
+          for (const rarity of rankedRarity) {
+            if (start) {
+              rarities.push(rarity);
+            } else if (rarity === value) {
+              start = true;
+              rarities.push(rarity);
+            }
+          }
+          break;
+        case ">":
+          let start2 = false;
+          for (const rarity of rankedRarity) {
+            if (start2) {
+              rarities.push(rarity);
+            } else if (rarity === value) {
+              start2 = true;
+            }
+          }
+          break;
+        case "<=":
+          let start3 = false;
+          for (const rarity of rankedRarity.slice().reverse()) {
+            if (start3) {
+              rarities.push(rarity);
+            } else if (rarity === value) {
+              start3 = true;
+              rarities.push(rarity);
+            }
+          }
+          break;
+        case "<":
+          let start4 = false;
+          for (const rarity of rankedRarity.slice().reverse()) {
+            if (start4) {
+              rarities.push(rarity);
+            } else if (rarity === value) {
+              start4 = true;
+            }
+          }
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  return {
+    filterToPropertyMapping: {
+      nestedProperty: "rarity",
+      property: "printings",
+      isArray: true
+    },
+    isExcluded,
+    isOptional,
+    isOr: true,
+    values: rarities
+  };
+};
+const getLegalFilters = (values, isExcluded, isOptional, additionalHeroes, filterPropertyOverride) => {
+  const cleanAdditionalHeroes = additionalHeroes.map((hero) => ({
+    hero: hero.toLowerCase().replaceAll(PUNCTUATION, "")
+  }));
+  const filters = [];
+  const formats = [];
+  const heroes = [];
+  for (const value of values) {
+    const matchingFormat = formatMappings.find(({ format, nicknames }) => {
+      const isAMatch = format === value || !!nicknames && nicknames.includes(value);
+      return isAMatch;
+    });
+    if (matchingFormat) {
+      formats.push(matchingFormat.format);
+    } else {
+      const matchingHero = heroMappings.find(({ hero, nicknames }) => {
+        const isAMatch = hero === value || !!nicknames && nicknames.includes(value);
+        return isAMatch;
+      }) || cleanAdditionalHeroes.find(({ hero }) => hero === value);
+      if (matchingHero) {
+        heroes.push(matchingHero.hero);
+      }
+    }
+  }
+  const filterProperty = filterPropertyOverride || "legalFormats";
+  if (formats.length > 0) {
+    filters.push({
+      filterToPropertyMapping: { property: filterProperty, isArray: true },
+      values: formats,
+      isOr: true,
+      isExcluded,
+      isOptional
+    });
+  }
+  if (heroes.length > 0) {
+    filters.push({
+      filterToPropertyMapping: {
+        property: "legalHeroes" /* LegalHeroes */,
+        isArray: true
+      },
+      values: heroes,
+      isOr: true,
+      isExcluded,
+      isOptional
+    });
+  }
+  return filters;
+};
+const getBannedFilters = (values, isExcluded, isOptional, additionalHeroes) => {
+  return getLegalFilters(
+    values,
+    isExcluded,
+    isOptional,
+    additionalHeroes,
+    "bannedFormats"
+  );
+};
+const getMetaFilters = (isExcluded, isOptional, filterKey, values, modifier, additionalHeroes) => {
+  const filters = [];
+  if (isLegalFilter(filterKey)) {
+    filters.push(
+      ...getLegalFilters(values, isExcluded, isOptional, additionalHeroes)
+    );
+  } else if (isBannedFilter(filterKey)) {
+    filters.push(
+      ...getBannedFilters(values, isExcluded, isOptional, additionalHeroes)
+    );
+  } else if (isRarityFilter(filterKey)) {
+    filters.push(getRarityFilter(values, modifier, isExcluded, isOptional));
+  }
+  return filters;
+};
+const noCost = [
+  {
+    filterToPropertyMapping: {
+      property: "cost",
+      isNumber: true
+    },
+    isExcluded: true,
+    values: oneToFifty
+  },
+  {
+    filterToPropertyMapping: {
+      property: "specialCost",
+      isString: true,
+      partialMatch: true
+    },
+    isExcluded: true,
+    values: ["*", "x"]
+  },
+  {
+    filterToPropertyMapping: {
+      property: "types",
+      isArray: true,
+      partialMatch: true
+    },
+    isExcluded: true,
+    values: ["equipment", "hero", "placeholder", "token", "weapon"]
+  }
+];
+const noDefense = [
+  {
+    filterToPropertyMapping: {
+      property: "defense",
+      isNumber: true
+    },
+    isExcluded: true,
+    values: oneToFifty
+  },
+  {
+    filterToPropertyMapping: {
+      property: "specialDefense",
+      isString: true,
+      partialMatch: true
+    },
+    isExcluded: true,
+    values: ["*", "x"]
+  },
+  {
+    filterToPropertyMapping: {
+      property: "types",
+      isArray: true,
+      partialMatch: true
+    },
+    isExcluded: true,
+    values: ["hero", "placeholder", "token", "weapon"]
+  }
+];
+const noPitch = [
+  {
+    filterToPropertyMapping: {
+      property: "pitch",
+      isNumber: true
+    },
+    isExcluded: true,
+    values: oneToFifty
+  },
+  {
+    filterToPropertyMapping: {
+      property: "types",
+      isArray: true,
+      partialMatch: true
+    },
+    isExcluded: true,
+    values: ["equipment", "hero", "placeholder", "token", "weapon"]
+  },
+  {
+    filterToPropertyMapping: {
+      property: "isCardBack",
+      isBoolean: true
+    },
+    isExcluded: true,
+    values: ["true"]
+  }
+];
+const noPower = [
+  {
+    filterToPropertyMapping: {
+      property: "power",
+      isNumber: true
+    },
+    isExcluded: true,
+    values: oneToFifty
+  },
+  {
+    filterToPropertyMapping: {
+      property: "specialPower",
+      isString: true,
+      partialMatch: true
+    },
+    isExcluded: true,
+    values: ["*", "x"]
+  },
+  {
+    filterToPropertyMapping: {
+      property: "types",
+      isArray: true,
+      partialMatch: true
+    },
+    isExcluded: true,
+    values: ["equipment", "hero", "placeholder", "token"]
+  }
+];
+const noTalents = [
+  {
+    filterToPropertyMapping: {
+      property: "talents",
+      isArray: true
+    },
+    isExcluded: true,
+    values: Object.values(Talent).map((talent) => talent.toLowerCase())
+  }
+];
+const excludedFilters = {
+  "!co": noCost,
+  "-co": noCost,
+  "!cost": noCost,
+  "-cost": noCost,
+  "!color": noCost,
+  "-color": noCost,
+  "!b": noDefense,
+  "-b": noDefense,
+  "!block": noDefense,
+  "-block": noDefense,
+  "!d": noDefense,
+  "-d": noDefense,
+  "!def": noDefense,
+  "-def": noDefense,
+  "!defense": noDefense,
+  "-defense": noDefense,
+  "!pitch": noPitch,
+  "-pitch": noPitch,
+  "!p": noPitch,
+  "-p": noPitch,
+  "!attack": noPower,
+  "-attack": noPower,
+  "!power": noPower,
+  "-power": noPower,
+  "!pwr": noPower,
+  "-pwr": noPower,
+  "!pow": noPower,
+  "-pow": noPower,
+  "!talents": noTalents,
+  "-talents": noTalents,
+  "!tal": noTalents,
+  "-tal": noTalents
+};
+const getExcludedMetaFilters = (filterKey) => {
+  const filters = [];
+  const matchingFilters = excludedFilters[filterKey];
+  if (matchingFilters) {
+    filters.push(...matchingFilters);
+  }
+  return filters;
+};
+const legalFilters = ["l", "legal", "hero"];
+const isLegalFilter = (filterKey) => legalFilters.includes(filterKey);
+const bannedFilters = ["banned"];
+const isBannedFilter = (filterKey) => bannedFilters.includes(filterKey);
+const rarityFilters = ["r", "rarity"];
+const isRarityFilter = (filterKey) => rarityFilters.includes(filterKey);
+export {
+  FilterProperty,
+  getExcludedMetaFilters,
+  getMetaFilters
+};

package/dist/related.js

@@ -0,0 +1,135 @@
+import { Hero, Trait } from "@flesh-and-blood/types";
+import { PUNCTUATION } from "./constants";
+import { Keyword } from "@flesh-and-blood/types";
+const nameOverrides = {
+  "Dawnblade, Resplendent": "Dawnblade"
+};
+const getOverrideOrName = (card) => nameOverrides[card.name] || card.name;
+const getFunctionalTextWithoutSelfReferences = (card) => card.functionalText?.replaceAll(card.name, "");
+const getRelatedCardsByName = (name, cards) => {
+  let card = cards.find(
+    (card2) => card2.name.toLowerCase().replace(PUNCTUATION, "") === name
+  );
+  if (!card) {
+    card = cards.find(
+      (card2) => card2.name.toLowerCase().replace(PUNCTUATION, "").includes(name)
+    );
+  }
+  return getRelatedCards(card, cards);
+};
+const getRelatedCards = (card, availableCards) => {
+  const otherPitchMapping = {};
+  const referencedByMapping = {};
+  const referencesMapping = {};
+  if (card) {
+    const initialReferencedBy = [];
+    const initialReferences = [];
+    const cardName = getOverrideOrName(card);
+    for (const other of availableCards) {
+      const otherName = getOverrideOrName(other);
+      const sameName = cardName === otherName;
+      const differentCard = card.cardIdentifier !== other.cardIdentifier;
+      const differentPitch = card.pitch !== other.pitch;
+      if (sameName && differentCard && differentPitch) {
+        otherPitchMapping[other.cardIdentifier] = other;
+      } else if (!sameName) {
+        const isCardSeismicSurge = card.name === "Seismic Surge";
+        const isOtherCardHeaved = other.keywords?.includes(Keyword.Heave);
+        const isOtherCardHeaveOverride = isCardSeismicSurge && isOtherCardHeaved;
+        const isCardMarked = card.name === "Marked";
+        const isOtherCardMarking = other.keywords?.includes(Keyword.Mark);
+        const isOtherCardMarkOverride = isCardMarked && isOtherCardMarking;
+        const otherFunctionalText = getFunctionalTextWithoutSelfReferences(other);
+        const cardIsInOtherFunctionalTextOrTraits = otherFunctionalText?.includes(cardName) || card.traits?.some((trait) => otherFunctionalText?.includes(trait));
+        const functionalText = getFunctionalTextWithoutSelfReferences(card);
+        if (cardIsInOtherFunctionalTextOrTraits || isOtherCardHeaveOverride || isOtherCardMarkOverride) {
+          initialReferencedBy.push(other);
+        }
+        const functionalTextRegex = new RegExp(otherName, "g");
+        const functionalTextKeywordRegex = new RegExp(
+          `\\*\\*${otherName}\\*\\*`,
+          "g"
+        );
+        const functionalTextReferences = functionalText?.match(functionalTextRegex) || [];
+        const functionalTextKeywordReferences = functionalText?.match(functionalTextKeywordRegex) || [];
+        const referenceIsKeywordOrFlow = functionalTextReferences.length === functionalTextKeywordReferences.length;
+        const otherCardIsInFunctionalText = functionalText?.includes(otherName) && !referenceIsKeywordOrFlow;
+        const otherCardTraits = other.traits || [];
+        const otherCardIsInTraits = otherCardTraits.some(
+          (otherCardTrait) => functionalText?.includes(otherCardTrait)
+        );
+        const otherCardIsInFunctionalTextOrTraits = otherCardIsInFunctionalText || otherCardIsInTraits;
+        const isOtherCardSeismicSurge = other.name === "Seismic Surge";
+        const isCardHeaved = card.keywords?.includes(Keyword.Heave);
+        const isCardHeaveOverride = isOtherCardSeismicSurge && isCardHeaved;
+        const isOtherCardMarked = other.name === "Marked";
+        const isCardMarking = card.keywords?.includes(Keyword.Mark);
+        const isCardMarkOverride = isOtherCardMarked && isCardMarking;
+        if (otherCardIsInFunctionalTextOrTraits || isCardHeaveOverride || isCardMarkOverride) {
+          initialReferences.push(other);
+        }
+      }
+    }
+    for (const initialReference of initialReferencedBy) {
+      referencedByMapping[initialReference.cardIdentifier] = initialReference;
+    }
+    for (const initialReference of initialReferences) {
+      const initialName = initialReference.name;
+      if (cardName !== initialName && !initialReferences.some((card2) => {
+        const name = card2.name;
+        return name !== initialName && name?.includes(initialName);
+      })) {
+        referencesMapping[initialReference.cardIdentifier] = initialReference;
+      }
+    }
+  }
+  const otherPitches = Object.values(otherPitchMapping);
+  const referencedBy = Object.values(referencedByMapping);
+  const references = Object.values(referencesMapping);
+  return { otherPitches, referencedBy, references };
+};
+const CARD_IDENTIFIERS_TO_SKIP = ["cash-in-yellow"];
+const heroReferences = {
+  [Hero.Crackni]: { traits: [Trait.AgentOfChaos] },
+  [Hero.Maxx]: { tokens: ["hyper-driver"] }
+};
+const getTokensReferencedByCards = (cards, availableTokens, hero) => {
+  const referencedTokens = /* @__PURE__ */ new Set();
+  for (const card of cards.filter(
+    ({ cardIdentifier }) => !CARD_IDENTIFIERS_TO_SKIP.includes(cardIdentifier)
+  )) {
+    const { references } = getRelatedCards(card, availableTokens);
+    for (const token of references.filter((token2) => {
+      const isHyperDriver = token2.name === "Hyper Driver";
+      const isMaxx = hero === Hero.Maxx;
+      return !isHyperDriver || isMaxx;
+    })) {
+      referencedTokens.add(token);
+    }
+  }
+  if (hero) {
+    const heroCards = heroReferences[hero];
+    if (heroCards) {
+      if (heroCards.cards) {
+        for (const card of cards) {
+          if (heroCards.cards?.includes(card.cardIdentifier)) {
+            referencedTokens.add(card);
+          }
+        }
+      }
+      if (heroCards.tokens) {
+        for (const token of availableTokens) {
+          if (heroCards.tokens?.includes(token.cardIdentifier)) {
+            referencedTokens.add(token);
+          }
+        }
+      }
+    }
+  }
+  return Array.from(referencedTokens);
+};
+export {
+  getRelatedCards,
+  getRelatedCardsByName,
+  getTokensReferencedByCards
+};