@flesh-and-blood/search 3.9.13 → 4.0.0

package/dist/search.js

@@ -0,0 +1,422 @@
+import {
+  setIdentifierToSetMappings,
+  setToSetIdentifierMappings
+} from "@flesh-and-blood/types";
+import Fuse from "fuse.js";
+import { PUNCTUATION } from "./constants";
+import { getKeywordsAndAppliedFiltersFromText } from "./filters";
+import { memes } from "./memes";
+import { getNormalizedText } from "./helpers";
+import { FilterProperty } from "./metaFilters";
+class Search {
+  constructor(cards, additionalHeroes = [], additionalSets = [], debug = false) {
+    this.log = (message, ...optionalParams) => {
+      if (this.debug) {
+        console.log(message, ...optionalParams);
+      }
+    };
+    this.search = (text, includeMemes) => {
+      let results;
+      const { appliedFilters, attributes, keywords } = getKeywordsAndAppliedFiltersFromText(
+        text,
+        this.cards,
+        this.additionalHeroes,
+        this.additionalSets
+      );
+      const keyword = keywords.join(" ");
+      const matchingMemes = includeMemes ? memes.filter((meme) => meme.keyword === keyword) : [];
+      if (matchingMemes.length > 0) {
+        results = matchingMemes.map(({ card }) => card);
+      } else if (keywords.length) {
+        results = this.fuse.search(keyword).map((result) => result.item);
+      } else {
+        results = [...this.cards];
+      }
+      if (appliedFilters.length) {
+        results = results.filter(
+          (card) => card && filterCard(card, appliedFilters)
+        );
+      }
+      if (keywords.length === 0) {
+        let setIdentifieToSortBy = "";
+        const shouldSortByRelease = attributes.releases.length === 1;
+        if (shouldSortByRelease) {
+          try {
+            const setToSort = attributes.releases[0];
+            const matchingSetIdentifiers = setToSetIdentifierMappings[setToSort];
+            setIdentifieToSortBy = matchingSetIdentifiers[0].toUpperCase();
+          } catch (e) {
+            console.error(`Error getting set identifier from search`, e);
+          }
+        }
+        const shouldSortByPrint = !setIdentifieToSortBy && attributes.prints.length === 1;
+        if (shouldSortByPrint) {
+          try {
+            const setToSort = attributes.prints[0];
+            const matchingSetIdentifiers = setIdentifierToSetMappings[setToSort];
+            if (matchingSetIdentifiers) {
+              setIdentifieToSortBy = setToSort.toUpperCase();
+            }
+          } catch (e) {
+            console.error(`Error getting set identifier from search`, e);
+          }
+        }
+        if (setIdentifieToSortBy) {
+          results.sort((c1, c2) => {
+            const c1SetNumber = c1.setIdentifiers.find((identifier) => identifier.includes(setIdentifieToSortBy))?.replace(setIdentifieToSortBy, "");
+            const c2SetNumber = c2.setIdentifiers.find((identifier) => identifier.includes(setIdentifieToSortBy))?.replace(setIdentifieToSortBy, "");
+            return c1SetNumber && c2SetNumber ? c1SetNumber.localeCompare(c2SetNumber) : -1;
+          });
+        } else {
+          results.sort(
+            (c1, c2) => c1.name === c2.name ? `${c1.pitch}`.localeCompare(`${c2.pitch}`) : c1.name.localeCompare(c2.name)
+          );
+        }
+      } else {
+        const nameMatches = [];
+        const nonMatches = [];
+        const potentialCardName = keywords.map((keyword2) => keyword2.toLowerCase().replace(PUNCTUATION, "")).join(" ");
+        for (const card of results) {
+          if (card.name.toLowerCase().replace(PUNCTUATION, "") === potentialCardName) {
+            nameMatches.push(card);
+          } else {
+            nonMatches.push(card);
+          }
+        }
+        results = [...nameMatches, ...nonMatches];
+      }
+      let searchResultsWithMatchingPrinting;
+      const {
+        artists,
+        isExpansionSlot,
+        foilings,
+        prints,
+        rarities,
+        releases,
+        treatments
+      } = attributes;
+      const shouldFindMatchingPrintings = artists.length > 0 || isExpansionSlot || foilings.length > 0 || prints.length > 0 || rarities.length > 0 || releases.length > 0 || treatments.length > 0;
+      if (shouldFindMatchingPrintings) {
+        searchResultsWithMatchingPrinting = results.map((card) => {
+          const matchingPrintings = card.printings.filter((printing) => {
+            const hasImage = !!printing.image;
+            const matchesArtist = artists.length === 0 || artists.some(
+              (attributeArtist) => printing.artists.find(
+                (artist) => artist.replace(PUNCTUATION, "").toLowerCase().includes(attributeArtist)
+              )
+            );
+            const matchesExpansionSlot = !isExpansionSlot || isExpansionSlot === printing.isExpansionSlot;
+            const matchesFoiling = foilings.length === 0 || foilings.includes(printing.foiling);
+            const matchesPrint = prints.length === 0 || prints.some(
+              (print) => printing.identifier.includes(print.toUpperCase())
+            );
+            const matchesRarity = rarities.length === 0 || rarities.includes(printing.rarity);
+            const matchesReleases = releases.length === 0 || releases.includes(printing.set);
+            const matchesTreatment = treatments.length === 0 || printing.treatments?.some(
+              (treatment) => treatments.includes(treatment)
+            );
+            const printMatches = hasImage && matchesArtist && matchesExpansionSlot && matchesFoiling && matchesPrint && matchesRarity && matchesReleases && matchesTreatment;
+            return printMatches;
+          });
+          return {
+            ...card,
+            matchingPrintings
+          };
+        });
+      }
+      const searchResults = searchResultsWithMatchingPrinting?.length > 0 ? searchResultsWithMatchingPrinting : results;
+      return {
+        appliedFilters,
+        attributes,
+        keywords,
+        searchResults
+      };
+    };
+    const searchOptions = {
+      getFn: (obj, path) => {
+        const value = Fuse.config.getFn(obj, path);
+        if (!value) {
+          return value;
+        } else if (Array.isArray(value)) {
+          return value.map(
+            (val) => getNormalizedText(val.replace(PUNCTUATION, ""))
+          );
+        } else {
+          return getNormalizedText(value).replace(PUNCTUATION, "");
+        }
+      },
+      ignoreLocation: true,
+      includeScore: true,
+      keys: [
+        { name: "name", weight: 10 },
+        { name: "functionalText", weight: 6 },
+        { name: "shorthands", weight: 4 },
+        { name: "setIdentifiers", weight: 2 },
+        { name: "traits", weight: 4 },
+        { name: "typeText", weight: 6 }
+      ],
+      threshold: 0.15,
+      useExtendedSearch: true
+    };
+    this.additionalHeroes = additionalHeroes;
+    this.additionalSets = additionalSets;
+    this.cards = [...cards];
+    this.debug = debug;
+    this.fuse = new Fuse([...cards], searchOptions);
+  }
+}
+var search_default = Search;
+const filterCard = (card, appliedFilters) => {
+  let doesCardMatchAllRequiredFilters = true;
+  let doesCardMatchAnyOptionalFilters = false;
+  for (const appliedFilter of appliedFilters) {
+    const isOptional = appliedFilter.isOptional;
+    const { isNumber, isString, isArray, isBoolean } = appliedFilter.filterToPropertyMapping;
+    if (isNumber) {
+      const cardMatchesNumericFilter = getDoesCardMatchNumericFilter(
+        card,
+        appliedFilter
+      );
+      if (isOptional) {
+        if (cardMatchesNumericFilter) {
+          doesCardMatchAnyOptionalFilters = true;
+        }
+      } else {
+        doesCardMatchAllRequiredFilters = doesCardMatchAllRequiredFilters && cardMatchesNumericFilter;
+      }
+    } else if (isString) {
+      const cardMatchesStringFilter = getDoesCardMatchStringFilter(
+        card,
+        appliedFilter
+      );
+      if (isOptional) {
+        if (cardMatchesStringFilter) {
+          doesCardMatchAnyOptionalFilters = true;
+        }
+      } else {
+        doesCardMatchAllRequiredFilters = doesCardMatchAllRequiredFilters && cardMatchesStringFilter;
+      }
+    } else if (isArray) {
+      const cardMatchesArrayFilter = getDoesCardMatchArrayFilter(
+        card,
+        appliedFilter,
+        appliedFilters
+      );
+      if (isOptional) {
+        if (cardMatchesArrayFilter) {
+          doesCardMatchAnyOptionalFilters = true;
+        }
+      } else {
+        doesCardMatchAllRequiredFilters = doesCardMatchAllRequiredFilters && cardMatchesArrayFilter;
+      }
+    } else if (isBoolean) {
+      const cardMatchesBooleanFilter = getDoesCardMatchBooleanFilter(
+        card,
+        appliedFilter
+      );
+      if (isOptional) {
+        if (cardMatchesBooleanFilter) {
+          doesCardMatchAnyOptionalFilters = true;
+        }
+      } else {
+        doesCardMatchAllRequiredFilters = doesCardMatchAllRequiredFilters && cardMatchesBooleanFilter;
+      }
+    }
+  }
+  return doesCardMatchAllRequiredFilters;
+};
+const getDoesCardMatchNumericFilter = (card, filter) => {
+  if (!doesFilterMatchCardType(filter, card)) {
+    return true;
+  } else {
+    const {
+      values,
+      modifier,
+      isExcluded: excluded,
+      filterToPropertyMapping: { partialMatch }
+    } = filter;
+    let cardValue = getCardValue(card, filter);
+    if (cardValue != null && !isNaN(cardValue)) {
+      cardValue = parseInt(cardValue);
+      if (modifier) {
+        switch (modifier) {
+          case ">=":
+            const isGreatherThanOrEqualTo = values?.some(
+              (filterValue) => cardValue >= parseInt(filterValue)
+            );
+            return excluded ? !isGreatherThanOrEqualTo : isGreatherThanOrEqualTo;
+          case ">":
+            const isGreatherThan = values?.some(
+              (filterValue) => cardValue > parseInt(filterValue)
+            );
+            return excluded ? !isGreatherThan : isGreatherThan;
+          case "<=":
+            const isLessThanOrEqualTo = values?.some(
+              (filterValue) => cardValue <= parseInt(filterValue)
+            );
+            return excluded ? !isLessThanOrEqualTo : isLessThanOrEqualTo;
+          case "<":
+            const isLessThan = values?.some(
+              (filterValue) => cardValue < parseInt(filterValue)
+            );
+            return excluded ? !isLessThan : isLessThan;
+          default:
+            return false;
+        }
+      } else {
+        const isEqualTo = values?.some(
+          (filterValue) => cardValue === parseInt(filterValue)
+        );
+        return excluded ? !isEqualTo : isEqualTo;
+      }
+    } else {
+      const cardSpecialValue = getCardSpecialValue(card, filter)?.toLowerCase();
+      const isMatch = partialMatch ? values?.some((filterValue) => cardSpecialValue?.includes(filterValue)) : values?.some((filterValue) => cardSpecialValue === filterValue);
+      return excluded ? !isMatch : isMatch;
+    }
+  }
+};
+const getDoesCardMatchStringFilter = (card, filter) => {
+  if (!doesFilterMatchCardType(filter, card)) {
+    return true;
+  } else {
+    const {
+      values,
+      isAnd,
+      isExcluded: excluded,
+      filterToPropertyMapping: { partialMatch }
+    } = filter;
+    const cardValue = getCardValue(card, filter)?.replaceAll(
+      PUNCTUATION,
+      ""
+    );
+    if (partialMatch) {
+      const isPartialMatch = isAnd ? values?.every(
+        (filterValue) => cardValue?.toLowerCase().includes(filterValue)
+      ) : values?.some(
+        (filterValue) => cardValue?.toLowerCase().includes(filterValue)
+      );
+      return excluded ? !isPartialMatch : isPartialMatch;
+    } else {
+      const isFullMatch = isAnd ? values?.every(
+        (filterValue) => cardValue?.toLowerCase() === filterValue
+      ) : values?.some(
+        (filterValue) => cardValue?.toLowerCase() === filterValue
+      );
+      return excluded ? !isFullMatch : isFullMatch;
+    }
+  }
+};
+const getDoesCardMatchArrayFilter = (card, filter, filters) => {
+  if (!doesFilterMatchCardType(filter, card)) {
+    return true;
+  } else {
+    const {
+      values,
+      isAnd,
+      isExcluded,
+      filterToPropertyMapping: { partialMatch }
+    } = filter;
+    const cardValues = getCardValues(card, filter, filters).map(
+      (value) => value?.replaceAll(PUNCTUATION, "")
+    );
+    if (partialMatch) {
+      const isPartialMatch = isAnd ? values.every(
+        (filterValue) => cardValues?.some(
+          (cardValue) => cardValue?.toLowerCase().includes(filterValue)
+        )
+      ) : values.some(
+        (filterValue) => cardValues?.some(
+          (cardValue) => cardValue?.toLowerCase().includes(filterValue)
+        )
+      );
+      const noValues = cardValues.length === 0;
+      return isExcluded ? !isPartialMatch || noValues : isPartialMatch;
+    } else {
+      const isFullMatch = isAnd ? values.every(
+        (filterValue) => cardValues?.some(
+          (cardValue) => cardValue?.toLowerCase() === filterValue
+        )
+      ) : values.some(
+        (filterValue) => cardValues?.some(
+          (cardValue) => cardValue?.toLowerCase() === filterValue
+        )
+      );
+      return isExcluded ? !isFullMatch : isFullMatch;
+    }
+  }
+};
+const getDoesCardMatchBooleanFilter = (card, filter) => {
+  if (!doesFilterMatchCardType(filter, card)) {
+    return true;
+  } else {
+    const { isExcluded } = filter;
+    const cardValue = getCardValue(card, filter);
+    return isExcluded ? !cardValue : cardValue;
+  }
+};
+const getCardValue = (card, appliedFilter) => {
+  const { filterToPropertyMapping } = appliedFilter;
+  return card[filterToPropertyMapping.property];
+};
+const getCardValues = (card, filter, filters) => {
+  const {
+    filterToPropertyMapping: {
+      isNestedPropertyArray,
+      nestedProperty,
+      property
+    }
+  } = filter;
+  const propertyValues = card[property] || [];
+  let values = [];
+  const cardHasLegalOverrides = Object.keys(card.legalOverrides || {}).length > 0;
+  const isCheckingForLegalHeroes = filter.filterToPropertyMapping.property === FilterProperty.LegalHeroes;
+  const anotherFilterForLegalFormat = filters.find(
+    ({ filterToPropertyMapping }) => filterToPropertyMapping.property === FilterProperty.LegalFormats
+  );
+  const shouldCheckForLegalOverrides = cardHasLegalOverrides && isCheckingForLegalHeroes && !!anotherFilterForLegalFormat;
+  if (shouldCheckForLegalOverrides) {
+    const valuesSet = /* @__PURE__ */ new Set();
+    for (const { format, heroes } of card.legalOverrides || []) {
+      if (anotherFilterForLegalFormat.values.includes(format.toLowerCase())) {
+        for (const hero of heroes) {
+          valuesSet.add(hero);
+        }
+      }
+    }
+    values = Array.from(valuesSet);
+  }
+  if (values.length === 0) {
+    if (nestedProperty) {
+      const valuesSet = /* @__PURE__ */ new Set();
+      for (const rawValue of propertyValues) {
+        if (isNestedPropertyArray) {
+          const rawValues = rawValue[nestedProperty] || [];
+          for (const value of rawValues) {
+            valuesSet.add(value);
+          }
+        } else {
+          const value = rawValue[nestedProperty];
+          if (value) {
+            valuesSet.add(value);
+          }
+        }
+      }
+      values = Array.from(valuesSet);
+    } else {
+      values = propertyValues;
+    }
+  }
+  return values;
+};
+const getCardSpecialValue = (card, appliedFilter) => {
+  const { filterToPropertyMapping } = appliedFilter;
+  return card[filterToPropertyMapping.specialProperty];
+};
+const doesFilterMatchCardType = ({ cardTypes }, { types, subtypes }) => !cardTypes || cardTypes?.some(
+  (cardType) => types.map((type) => type.toLowerCase()).includes(cardType.toLowerCase()) || subtypes.map((subtype) => subtype.toLowerCase()).includes(cardType.toLowerCase())
+);
+export {
+  search_default as default,
+  filterCard
+};

package/dist/shorthands.js

@@ -0,0 +1,174 @@
+import { Keyword, Subtype, Type } from "@flesh-and-blood/types";
+const shorthands = [
+  {
+    description: "Attack actions",
+    expanded: ["st:attack"],
+    filters: {
+      subtypes: [Subtype.Attack]
+    },
+    isCardProperty: false,
+    shorthands: ["AA"]
+  },
+  {
+    description: "Arcane barrier",
+    expanded: ['k:"arcane barrier"'],
+    filters: {
+      keywords: [Keyword.ArcaneBarrier]
+    },
+    isCardProperty: false,
+    shorthands: ["AB"]
+  },
+  {
+    description: "Attack reactions",
+    expanded: ['t:"attack reaction"'],
+    filters: {
+      types: [Type.AttackReaction]
+    },
+    isCardProperty: false,
+    shorthands: ["AR"]
+  },
+  {
+    description: "Defense reactions",
+    expanded: ['t:"defense reaction"'],
+    filters: {
+      types: [Type.DefenseReaction]
+    },
+    isCardProperty: false,
+    shorthands: ["DR"]
+  },
+  // {
+  //   description: "Flick daggers",
+  //   expanded: ["dagger you control deal 1 damage"],
+  //   filters: {
+  //     functionalText: "dagger you control deal 1 damage",
+  //   },
+  //   isCardProperty: true,
+  //   shorthands: ["Flick", "Hurl", "Throw"],
+  // },
+  {
+    description: "Gain life",
+    expanded: ["gain {h}"],
+    filters: {
+      functionalText: "gain {h}"
+    },
+    isCardProperty: false,
+    shorthands: ["Gain life", "Gains life"]
+  },
+  {
+    description: "Go again",
+    expanded: ['k:"go again"'],
+    filters: {
+      keywords: [Keyword.GoAgain]
+    },
+    isCardProperty: false,
+    shorthands: ["GA"]
+  },
+  {
+    description: "Non-attack actions",
+    expanded: ["t:action", "st:non-attack"],
+    filters: {
+      subtypes: [Subtype.NonAttack],
+      types: [Type.Action]
+    },
+    isCardProperty: false,
+    shorthands: ["NAA"]
+  },
+  {
+    description: "Plus defense",
+    expanded: ["+ {d}"],
+    filters: {
+      functionalText: "+ {d}"
+    },
+    isCardProperty: false,
+    shorthands: [
+      "Pump defense",
+      "Pumps defense",
+      "Buff defense",
+      "Buffs defense"
+    ]
+  },
+  // {
+  //   description: "Plus power",
+  //   expanded: ["+ {p}"],
+  //   filters: {
+  //     functionalText: "+ {p}",
+  //   },
+  //   isCardProperty: false,
+  //   shorthands: [
+  //     "Pumps",
+  //     "Pump",
+  //     "Buff",
+  //     "Buffs",
+  //     "Pump attack",
+  //     "Pump attacks",
+  //     "Pumps attack",
+  //     "Pumps attacks",
+  //     "Buff attack",
+  //     "Buff attacks",
+  //     "Buffs attack",
+  //     "Buffs attacks",
+  //     "Pump power",
+  //     "Pumps power",
+  //     "Buff power",
+  //     "Buffs power",
+  //   ],
+  // },
+  // {
+  //   description: "Poppers",
+  //   expanded: ["!c:illusionist", "st:attack", "pwr:>=6", "def:>=0"],
+  //   filters: {
+  //     defenseGreaterThanOrEqualTo: 0,
+  //     notClass: [Class.Illusionist],
+  //     powerGreaterThanOrEqualTo: 6,
+  //     subtypes: [Subtype.Attack],
+  //   },
+  //   isCardProperty: false,
+  //   helper:
+  //     '6+ power non-Illusionist attacks that can "pop" phantasm attacks when defending',
+  //   shorthands: ["Poppers", "Popper"],
+  // },
+  {
+    description: "Spellvoid",
+    expanded: ['k:"spellvoid"'],
+    filters: {
+      keywords: [Keyword.Spellvoid]
+    },
+    isCardProperty: false,
+    shorthands: ["SV"]
+  }
+  // {
+  //   description: "Tap",
+  //   expanded: ["{t}"],
+  //   filters: {
+  //     functionalText: "{t}",
+  //   },
+  //   isCardProperty: true,
+  //   shorthands: ["Tap"],
+  // },
+  // {
+  //   description: "Untap",
+  //   expanded: ["{u}"],
+  //   filters: {
+  //     functionalText: "{u}",
+  //   },
+  //   isCardProperty: true,
+  //   shorthands: ["Untap"],
+  // },
+];
+const multiWordShorthands = shorthands.filter(
+  ({ shorthands: shorthands2 }) => shorthands2.some((shorthand) => shorthand.includes(" "))
+).map((shorthand) => ({
+  ...shorthand,
+  shorthands: shorthand.shorthands.filter((shorthand2) => shorthand2.includes(" ")).map((shorthand2) => shorthand2.toLowerCase()).sort((s1, s2) => s2.length - s1.length)
+}));
+const singleWordShorthands = shorthands.filter(
+  ({ shorthands: shorthands2 }) => shorthands2.some((shorthand) => !shorthand.includes(" "))
+).map((shorthand) => ({
+  ...shorthand,
+  shorthands: shorthand.shorthands.filter((shorthand2) => !shorthand2.includes(" ")).map((shorthand2) => shorthand2.toLowerCase()).sort((s1, s2) => s2.length - s1.length)
+}));
+export {
+  multiWordShorthands,
+  shorthands,
+  singleWordShorthands
+};

package/package.json

@@ -1,23 +1,50 @@
 {
   "name": "@flesh-and-blood/search",
   "description": "TypeScript search engine for Flesh and Blood cards",
-  "version": "3.9.13",
-  "main": "dist/index.js",
+  "version": "4.0.0",
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./abbreviations": {
+      "types": "./dist/abbreviations.d.ts",
+      "import": "./dist/abbreviations.js"
+    },
+    "./shorthands": {
+      "types": "./dist/shorthands.d.ts",
+      "import": "./dist/shorthands.js"
+    },
+    "./memes": {
+      "types": "./dist/memes.d.ts",
+      "import": "./dist/memes.js"
+    }
+  },
   "scripts": {
     "prebuild": "rm -rf dist",
-    "build": "esbuild src/index.ts --outdir=dist --external:*.test.ts --external:fab-cards --bundle --minify --platform=node --target=es6",
+    "build": "npm run build:esm && npm run build:cjs",
+    "build:esm": "esbuild src/*.ts --outdir=dist --format=esm --platform=neutral --target=es2020",
+    "build:cjs": "esbuild src/index.ts --outfile=dist/index.cjs --bundle --minify --format=cjs --platform=node --target=es2020 --external:@flesh-and-blood/types --external:fuse.js",
     "postbuild": "tsc --declaration && npm test",
     "test": "jest",
     "test:specific": "jest -t 'Matching printing from treatment'",
     "full": "npm i && npm run build"
   },
   "dependencies": {
-    "@flesh-and-blood/types": "^3.9.7",
     "fuse.js": "^6.6.2"
   },
+  "peerDependencies": {
+    "@flesh-and-blood/types": "^3.9.7"
+  },
   "devDependencies": {
-    "@flesh-and-blood/cards": "^3.9.13",
+    "@flesh-and-blood/cards": "^4.0.0",
+    "@flesh-and-blood/types": "^4.0.0",
     "@types/jest": "^29.5.11",
     "@types/node": "^20.10.5",
     "esbuild": "^0.19.10",
@@ -47,5 +74,5 @@
     "FAB",
     "FABTCG"
   ],
-  "gitHead": "8511fb800f6a8284cc2b30fc0e2a36a57a87774a"
+  "gitHead": "9ded4ed228786d702f9c16ebe94d090dc4e73f23"
 }