@flesh-and-blood/types 3.9.7 → 4.0.3

package/dist/helpers/cards.d.ts

@@ -1,4 +1,4 @@
-import { Card, Type, Keyword, Subtype, Trait } from "../interfaces";
+import { Card, Type, Keyword, Subtype, Trait } from "../interfaces.js";
 export declare const getCardIdentifier: (card: {
     name: string;
     pitch?: string | number;

package/dist/helpers/cards.js

@@ -0,0 +1,140 @@
+import { Type, Keyword, Subtype, Trait } from "../interfaces.js";
+const getCardIdentifier = (card, useNumber) => {
+  const { name: unformattedName, pitch } = card;
+  const name = unformattedName.trim().toLowerCase().replace("//", "-").normalize("NFD").replace(/\p{Diacritic}/gu, "").replace(/ /g, "-").replace("\xF0", "d").replace("\u0111", "d").replace("\xED", "i").replace(/[^a-z0-9 -]/g, "").replace(/--/, "-");
+  let suffix = "";
+  switch (pitch) {
+    case "1":
+    case 1:
+      suffix = useNumber ? "-1" : "-red";
+      break;
+    case "2":
+    case 2:
+      suffix = useNumber ? "-2" : "-yellow";
+      break;
+    case "3":
+    case 3:
+      suffix = useNumber ? "-3" : "-blue";
+      break;
+  }
+  return `${name}${suffix}`;
+};
+const getCardFromGEMCardIdentifier = (gemCardIdentifier, cards) => {
+  let exactMatch;
+  let fallbackMatch;
+  const identifierParts = gemCardIdentifier.split("-");
+  const cardIdentifierGuess = identifierParts.map((part) => {
+    const shouldReplaceNumberWithColor = ["1", "2", "3"].some(
+      (pitch) => pitch === part
+    );
+    return shouldReplaceNumberWithColor ? part.replace("1", "red").replace("2", "yellow").replace("3", "blue") : part;
+  }).join("-");
+  for (const card of cards) {
+    const { cardIdentifier, oppositeSideCardIdentifiers } = card;
+    const matchesExactly = cardIdentifier === cardIdentifierGuess;
+    if (matchesExactly) {
+      exactMatch = card;
+      break;
+    }
+    const matchesDoubleSidedGuess = oppositeSideCardIdentifiers?.some(
+      (oppositeSideCardIdentifier) => `${cardIdentifier}--${oppositeSideCardIdentifier}` === cardIdentifierGuess
+    );
+    if (matchesDoubleSidedGuess) {
+      fallbackMatch = card;
+    }
+  }
+  return exactMatch || fallbackMatch;
+};
+const getFrontAndBackCardIdentifier = (card, cardBack, useNumber) => {
+  const cardFrontIdentifier = getCardIdentifier(card, useNumber);
+  const cardBackIdentifier = cardBack ? getCardIdentifier(cardBack, useNumber) : "";
+  const joiner = cardBackIdentifier ? "--" : "";
+  return `${cardFrontIdentifier}${joiner}${cardBackIdentifier}`;
+};
+const getIsArenaCard = ({
+  keywords,
+  traits,
+  types
+}) => {
+  const isDeckCard = getIsDeckCard({ keywords, traits, types });
+  const isToken = getIsCardTokenForDeck({
+    keywords,
+    traits,
+    types
+  });
+  const isInventoryCardType = [
+    Type.Companion,
+    Type.DemiHero,
+    Type.Equipment,
+    Type.Weapon
+  ].some((type) => types.includes(type));
+  return !isDeckCard && !isToken && isInventoryCardType;
+};
+const getIsDeckCard = ({
+  keywords,
+  traits,
+  types
+}) => {
+  const isDeckCardType = [
+    Type.Action,
+    Type.AttackReaction,
+    Type.Block,
+    Type.DefenseReaction,
+    Type.Instant,
+    Type.Mentor,
+    Type.Resource
+  ].some((type) => types.includes(type));
+  const isToken = getIsCardTokenForDeck({
+    keywords,
+    traits,
+    types
+  });
+  return isDeckCardType && !isToken;
+};
+const getIsCardTokenForDeck = ({
+  keywords,
+  traits,
+  types
+}) => {
+  const isAgentOfChaos = !!traits && traits?.includes(Trait.AgentOfChaos);
+  const isEphemeral = !!keywords && keywords.includes(Keyword.Ephemeral);
+  const isHeroMacroOrToken = [Type.Macro, Type.Token].some(
+    (type) => types.includes(type)
+  );
+  return isAgentOfChaos || isEphemeral || isHeroMacroOrToken;
+};
+const TOKEN_CARD_OVERRIDES = ["cracked-bauble-yellow", "goldfin-harpoon"];
+const getCanCardBeTokenForDeck = (card) => {
+  const isTokenOverride = TOKEN_CARD_OVERRIDES.includes(card.cardIdentifier);
+  const isToken = getIsCardTokenForDeck(card);
+  const cardBackCanBeOutsideDeck = card.isCardBack && card.cardIdentifier !== "inner-chi-blue";
+  return isTokenOverride || isToken || cardBackCanBeOutsideDeck;
+};
+const getCanAddToDeck = ({
+  isCardBack,
+  keywords,
+  traits,
+  types
+}) => {
+  const isArenaCard = getIsArenaCard({ keywords, traits, types });
+  const isDeckCard = getIsDeckCard({ keywords, traits, types });
+  const isCardFront = !isCardBack;
+  return isCardFront && (isArenaCard || isDeckCard);
+};
+const getShouldRotateCardImage = (card) => {
+  const isMeld = card.keywords?.includes(Keyword.Meld);
+  const isMacro = card.types?.includes(Type.Macro);
+  const isLandmarkThatShouldRotate = !isMacro && card.subtypes?.includes(Subtype.Landmark) || false;
+  return isMeld || isLandmarkThatShouldRotate;
+};
+export {
+  getCanAddToDeck,
+  getCanCardBeTokenForDeck,
+  getCardFromGEMCardIdentifier,
+  getCardIdentifier,
+  getFrontAndBackCardIdentifier,
+  getIsArenaCard,
+  getIsCardTokenForDeck,
+  getIsDeckCard,
+  getShouldRotateCardImage
+};

package/dist/helpers/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./cards";
-export * from "./printings";
+export * from "./cards.js";
+export * from "./printings.js";

package/dist/helpers/index.js

@@ -0,0 +1,2 @@
+export * from "./cards.js";
+export * from "./printings.js";

package/dist/helpers/printings.d.ts

@@ -1,4 +1,4 @@
-import { Printing } from "../interfaces";
+import { Printing } from "../interfaces.js";
 export declare const getPrint: (printing: {
     identifier: string;
     image?: string;

package/dist/helpers/printings.js

@@ -0,0 +1,432 @@
+import {
+  Treatment,
+  Foiling,
+  ReleaseEdition
+} from "../interfaces.js";
+import { fullSetIdentifiers } from "../sets.js";
+const identifierExtensionMapping = {
+  // [Release.RhinarBlitzDeck]: "-Blitz",
+};
+const suffixOverrides = {
+  "FAB470-RFB": "-V2",
+  "FAB470-RFC": "-V3",
+  "OMN203-MVB": "-V2",
+  "OMN203-MVC": "-V3",
+  "MPG112-A": "-V2",
+  "MPG112-B": "-V3",
+  MPG112_V2: "-V2",
+  MPG112_V3: "-V3",
+  MST158_V3: "-V3",
+  "ROS162-B": "-V2",
+  ROS162_V2: "-V2",
+  "ROS008-MV_V2_BACK": "-V3",
+  SUP009_V3: "-V3",
+  SUP009_V3_BACK: "-V3",
+  "HER146-ARF": "-ARF"
+};
+const getPrint = (printing) => {
+  const identifierExtension = identifierExtensionMapping[printing.set] || "";
+  const identifier = `${printing.identifier}${identifierExtension}`;
+  const edition = printing.edition ? `-${printing.edition}` : ``;
+  const foiling = printing.foiling ? `-${printing.foiling}` : ``;
+  const treatment = printing.treatments?.length ? `-${printing.treatments.sort().join("-")}` : printing.treatment ? `-${printing.treatment}` : ``;
+  const back = printing.image?.toLowerCase().includes("back") ? `-Back` : ``;
+  const suffix = suffixOverrides[printing.image?.toUpperCase() || ""] || "";
+  return `${identifier}${edition}${foiling}${treatment}${back}${suffix}`;
+};
+const orderedFullSetBlackBorderIdentifiers = Object.keys(
+  fullSetIdentifiers
+).filter((set) => !set.toLowerCase().includes("hp")).reverse().map((set) => set.toUpperCase());
+const SPECIAL_IMAGE_PRINTING_OVERRIDES = {
+  "adaptive-plating": {
+    print: "EVO013-Cold"
+  },
+  "command-and-conquer-red": {
+    print: "ANQ009-Rainbow-Alternate Art-Alternate Border-Extended Art"
+  },
+  "cracked-bauble-yellow": {
+    print: "LGS083-Cold"
+  },
+  "dash-io": {
+    print: "HER089-Cold"
+  },
+  "fate-foreseen-red": {
+    print: "FAB024-Rainbow"
+  },
+  "florian-rotwood-harbinger": {
+    print: "ROS001-Cold-Full Art-Back"
+  },
+  "pleiades-superstar": {
+    print: "SUP009-Cold-Full Art"
+  },
+  "pitfall-trap-yellow": {
+    print: "LGS151-Rainbow"
+  },
+  "prism-sculptor-of-arc-light": {
+    print: "HER069-Cold-Full Art-Back"
+  },
+  quicken: {
+    print: "EVO250"
+  },
+  "ravenous-rabble-red": {
+    print: "FAB190-Rainbow-Extended Art"
+  },
+  "rockslide-trap-blue": {
+    print: "LGS152-Rainbow"
+  },
+  "rosetta-thorn": {
+    print: "ROS256-Cold"
+  },
+  "sigil-of-solace-red": {
+    print: "FAB178-Rainbow-Alternate Art-Extended Art"
+  },
+  "spectral-shield": {
+    print: "MST158-Alternate Art-V3"
+  },
+  "tripwire-trap-red": {
+    print: "LGS150-Rainbow"
+  },
+  "viserai-rune-blood": {
+    print: "HER011-Cold"
+  },
+  "wreck-havoc-red": {
+    print: "OUT198"
+  }
+};
+const printingsToIgnore = ["JDG044-Full Art-Back"];
+const getSpecialPrinting = (card, printings) => {
+  const { cardIdentifier } = card;
+  const matchingOverride = Object.entries(
+    SPECIAL_IMAGE_PRINTING_OVERRIDES
+  ).find(([identifier]) => identifier === cardIdentifier);
+  const printingsIncludeMatchingOverride = !!matchingOverride && printings.some((printing) => {
+    const [, { print }] = matchingOverride;
+    return printing.print === print;
+  });
+  if (printingsIncludeMatchingOverride) {
+    const [, { print }] = matchingOverride;
+    const matchingPrint = printings.find(
+      (printing) => printing.print === print
+    );
+    return matchingPrint || printings[0];
+  } else {
+    let firstImage;
+    let alternativeArt;
+    let alternateBorder;
+    let alternateText;
+    let coldExtendedArt;
+    let coldFullArt;
+    let coldFullArt2;
+    let extendedArt;
+    let backFullArt;
+    let frontFullArt;
+    let firstFullArt;
+    let nonFoilExtendedArt;
+    let promoExtendedArt;
+    let fullArtAlternateArt;
+    let marvel;
+    let alphaEdition;
+    let firstEdition;
+    let promoEdition;
+    let unlimitedEdition;
+    let coldFoil;
+    let promoColdFoil;
+    for (const printing of printings) {
+      const { edition, foiling, identifier, image, print, treatments } = printing;
+      const upperCaseImage = image?.toUpperCase() || "";
+      const isMissingFunctionalText = identifier.toLowerCase().includes("win");
+      const hasImage = !!upperCaseImage;
+      const isGoldFoil = foiling === Foiling.Gold;
+      const isWhiteBorder = upperCaseImage.includes("HP");
+      const shouldIgnore = printingsToIgnore.includes(print);
+      const shouldConsiderPrinting = hasImage && !isMissingFunctionalText && !isWhiteBorder && !shouldIgnore && !isGoldFoil;
+      if (shouldConsiderPrinting) {
+        if (!firstImage) {
+          firstImage = printing;
+        }
+        if (treatments?.includes(Treatment.FA)) {
+          firstFullArt = printing;
+          if (foiling === Foiling.Cold) {
+            coldFullArt = printing;
+            if (upperCaseImage.includes("_V3")) {
+              coldFullArt2 = printing;
+              break;
+            }
+          }
+          if (upperCaseImage.includes("BACK")) {
+            backFullArt = printing;
+          } else {
+            frontFullArt = printing;
+          }
+        }
+        if (treatments?.includes(Treatment.EA)) {
+          extendedArt = printing;
+          if (foiling === Foiling.Cold) {
+            coldExtendedArt = printing;
+          }
+          if (!foiling) {
+            nonFoilExtendedArt = printing;
+          }
+          if (edition === ReleaseEdition.Promo) {
+            promoExtendedArt = printing;
+          }
+        }
+        if (treatments?.includes(Treatment.AA)) {
+          alternativeArt = printing;
+        }
+        if (treatments?.includes(Treatment.AB)) {
+          alternateBorder = printing;
+        }
+        if (treatments?.includes(Treatment.AT)) {
+          alternateText = printing;
+        }
+        if ((upperCaseImage.includes("_V2") || upperCaseImage.includes("-MV")) && treatments?.includes(Treatment.FA)) {
+          marvel = printing;
+        }
+        if (edition === ReleaseEdition.Alpha) {
+          alphaEdition = printing;
+        } else if (edition === ReleaseEdition.First) {
+          firstEdition = printing;
+        } else if (edition === ReleaseEdition.Promo) {
+          promoEdition = printing;
+        } else if (edition === ReleaseEdition.Unlimited) {
+          unlimitedEdition = printing;
+        }
+        if (foiling === Foiling.Cold) {
+          coldFoil = printing;
+          if (edition === ReleaseEdition.Promo) {
+            promoColdFoil = printing;
+          }
+        }
+      }
+    }
+    const finalFullArt = fullArtAlternateArt || coldFullArt2 || frontFullArt || backFullArt || coldFullArt || firstFullArt;
+    return finalFullArt || coldExtendedArt || marvel || promoExtendedArt || nonFoilExtendedArt || extendedArt || alternateBorder || alternativeArt || alternateText || promoColdFoil || alphaEdition || firstEdition || promoEdition || unlimitedEdition || coldFoil || firstImage;
+  }
+};
+const DEFAULT_IMAGE_PRINTING_OVERRIDES = {
+  "command-and-conquer-red": {
+    print: "HNT260"
+  },
+  "fyendals-spring-tunic": {
+    print: "EVO249"
+  },
+  might: {
+    print: "TER028"
+  },
+  "pitfall-trap-yellow": {
+    print: "LGS151-Rainbow"
+  },
+  "portside-exchange-blue": {
+    print: "SEA145"
+  },
+  "rockslide-trap-blue": {
+    print: "LGS152-Rainbow"
+  },
+  "rosetta-thorn": {
+    print: "ELE222-First"
+  },
+  "spectral-shield": {
+    print: "MST158"
+  },
+  "tripwire-trap-red": {
+    print: "LGS150-Rainbow"
+  },
+  vigor: {
+    print: "HVY242"
+  },
+  "wreck-havoc-red": {
+    print: "OUT198"
+  }
+};
+const getDefaultPrinting = (card, printings) => {
+  const { cardIdentifier } = card;
+  const matchingOverride = Object.entries(
+    DEFAULT_IMAGE_PRINTING_OVERRIDES
+  ).find(([identifier]) => identifier === cardIdentifier);
+  const printingsIncludeMatchingOverride = !!matchingOverride && printings.some((printing) => {
+    const [, { print }] = matchingOverride;
+    return printing.print === print;
+  });
+  if (printingsIncludeMatchingOverride) {
+    const [, { print }] = matchingOverride;
+    const matchingPrint = printings.find(
+      (printing) => printing.print === print
+    );
+    return matchingPrint || printings[0];
+  } else {
+    let firstImage;
+    let nonPromoImage;
+    for (const printing of printings) {
+      const { edition, image, treatment } = printing;
+      const hasImage = !!image;
+      const isWhiteBorder = image?.includes("HP");
+      const isCardBack = image?.includes("BACK");
+      const isAMessyImageName = (image || "").length > 10 || image?.includes("width");
+      const shouldConsiderPrinting = hasImage && !isWhiteBorder && !isCardBack && !isAMessyImageName;
+      if (shouldConsiderPrinting) {
+        if (!firstImage) {
+          firstImage = printing;
+        }
+        if (!nonPromoImage && edition !== ReleaseEdition.Promo && treatment !== Treatment.FA) {
+          nonPromoImage = printing;
+        }
+      }
+      if (firstImage && nonPromoImage) {
+        break;
+      }
+    }
+    return nonPromoImage || firstImage || printings[0];
+  }
+};
+const BOOMER_IMAGE_PRINTING_OVERRIDES = {};
+const getBoomerPrinting = (card, printings) => {
+  const { cardIdentifier } = card;
+  const matchingOverride = Object.entries(BOOMER_IMAGE_PRINTING_OVERRIDES).find(
+    ([identifier]) => identifier === cardIdentifier
+  );
+  const printingsIncludeMatchingOverride = !!matchingOverride && printings.some((printing) => {
+    const [, { print }] = matchingOverride;
+    return printing.print === print;
+  });
+  if (printingsIncludeMatchingOverride) {
+    const [, { print }] = matchingOverride;
+    const matchingPrint = printings.find(
+      (printing) => printing.print === print
+    );
+    return matchingPrint || printings[0];
+  } else {
+    let firstPrinting = printings.length > 0 ? printings[0] : void 0;
+    for (const release of Object.values(fullSetIdentifiers)) {
+      const matchingPrinting = printings.find(
+        (printing) => printing.set === release
+      );
+      if (matchingPrinting) {
+        firstPrinting = matchingPrinting;
+        break;
+      }
+    }
+    return firstPrinting;
+  }
+};
+const MAX_RARITY_IMAGE_PRINTING_OVERRIDES = {};
+const getMaxRarityPrinting = (card, printings) => {
+  const { cardIdentifier } = card;
+  const matchingOverride = Object.entries(
+    MAX_RARITY_IMAGE_PRINTING_OVERRIDES
+  ).find(([identifier]) => identifier === cardIdentifier);
+  const printingsIncludeMatchingOverride = !!matchingOverride && printings.some((printing) => {
+    const [, { print }] = matchingOverride;
+    return printing.print === print;
+  });
+  if (printingsIncludeMatchingOverride) {
+    const [, { print }] = matchingOverride;
+    const matchingPrint = printings.find(
+      (printing) => printing.print === print
+    );
+    return matchingPrint || printings[0];
+  } else {
+    let firstImage;
+    let alternativeArt;
+    let alternateBorder;
+    let alternateText;
+    let coldExtendedArt;
+    let coldFullArt;
+    let coldFullArt2;
+    let extendedArt;
+    let backFullArt;
+    let frontFullArt;
+    let firstFullArt;
+    let nonFoilExtendedArt;
+    let promoExtendedArt;
+    let fullArtAlternateArt;
+    let marvel;
+    let alphaEdition;
+    let firstEdition;
+    let promoEdition;
+    let unlimitedEdition;
+    let coldFoil;
+    let goldFoil;
+    let promoColdFoil;
+    for (const printing of printings) {
+      const { edition, foiling, identifier, image, print, treatments } = printing;
+      const upperCaseImage = image?.toUpperCase() || "";
+      const isMissingFunctionalText = identifier.toLowerCase().includes("win");
+      const hasImage = !!upperCaseImage;
+      const isWhiteBorder = upperCaseImage.includes("HP");
+      const shouldIgnore = printingsToIgnore.includes(print);
+      const shouldConsiderPrinting = hasImage && !isMissingFunctionalText && !isWhiteBorder && !shouldIgnore;
+      if (shouldConsiderPrinting) {
+        if (!firstImage) {
+          firstImage = printing;
+        }
+        if (treatments?.includes(Treatment.FA)) {
+          firstFullArt = printing;
+          if (foiling === Foiling.Cold) {
+            coldFullArt = printing;
+            if (upperCaseImage.includes("_V3")) {
+              coldFullArt2 = printing;
+              break;
+            }
+          }
+          if (upperCaseImage.includes("BACK")) {
+            backFullArt = printing;
+          } else {
+            frontFullArt = printing;
+          }
+        }
+        if (treatments?.includes(Treatment.EA)) {
+          extendedArt = printing;
+          if (foiling === Foiling.Cold) {
+            coldExtendedArt = printing;
+          }
+          if (!foiling) {
+            nonFoilExtendedArt = printing;
+          }
+          if (edition === ReleaseEdition.Promo) {
+            promoExtendedArt = printing;
+          }
+        }
+        if (treatments?.includes(Treatment.AA)) {
+          alternativeArt = printing;
+        }
+        if (treatments?.includes(Treatment.AB)) {
+          alternateBorder = printing;
+        }
+        if (treatments?.includes(Treatment.AT)) {
+          alternateText = printing;
+        }
+        if ((upperCaseImage.includes("_V2") || upperCaseImage.includes("-MV")) && treatments?.includes(Treatment.FA)) {
+          marvel = printing;
+        }
+        if (edition === ReleaseEdition.Alpha) {
+          alphaEdition = printing;
+        } else if (edition === ReleaseEdition.First) {
+          firstEdition = printing;
+        } else if (edition === ReleaseEdition.Promo) {
+          promoEdition = printing;
+        } else if (edition === ReleaseEdition.Unlimited) {
+          unlimitedEdition = printing;
+        }
+        if (foiling === Foiling.Cold) {
+          coldFoil = printing;
+          if (edition === ReleaseEdition.Promo) {
+            promoColdFoil = printing;
+          }
+        } else if (foiling === Foiling.Gold) {
+          goldFoil = printing;
+        }
+      }
+    }
+    const finalFullArt = fullArtAlternateArt || coldFullArt2 || frontFullArt || backFullArt || coldFullArt || firstFullArt;
+    return goldFoil || finalFullArt || coldExtendedArt || marvel || promoColdFoil || promoExtendedArt || coldFoil || nonFoilExtendedArt || extendedArt || alternateBorder || alternativeArt || alternateText || alphaEdition || promoEdition || firstEdition || unlimitedEdition || firstImage;
+  }
+};
+export {
+  getBoomerPrinting,
+  getDefaultPrinting,
+  getMaxRarityPrinting,
+  getPrint,
+  getSpecialPrinting,
+  orderedFullSetBlackBorderIdentifiers
+};