@flesh-and-blood/search 3.9.13 → 4.0.0

package/dist/filters.js

@@ -0,0 +1,695 @@
+import {
+  Foiling,
+  Meta,
+  Rarity,
+  Release,
+  Treatment,
+  Type,
+  setIdentifierToSetMappings,
+  setToSetIdentifierMappings
+} from "@flesh-and-blood/types";
+import { getAbbreviation } from "./abbreviations";
+import { getExcludedMetaFilters, getMetaFilters } from "./metaFilters";
+import { multiWordShorthands, singleWordShorthands } from "./shorthands";
+import { PUNCTUATION } from "./constants";
+import { getCardByName, getRelatedCardsByName } from ".";
+const availableModifiers = [">=", ">", "<=", "<"];
+const availableExclusions = ["!", "-"];
+const arcaneFilter = {
+  property: "arcane",
+  specialProperty: "specialArcane",
+  isNumber: true,
+  partialMatch: true
+};
+const artistFilter = {
+  property: "artists",
+  isArray: true,
+  partialMatch: true
+};
+const bannedFilter = {
+  property: "n/a",
+  isMeta: true
+};
+const bondFilter = {
+  property: "bonds",
+  isArray: true
+};
+const chainFilter = {
+  property: "n/a"
+};
+const classFilter = {
+  property: "classes",
+  isArray: true,
+  partialMatch: true
+};
+const costFilter = {
+  property: "cost",
+  specialProperty: "specialCost",
+  isNumber: true,
+  partialMatch: true
+};
+const defenseFilter = {
+  property: "defense",
+  specialProperty: "specialDefense",
+  isNumber: true
+};
+const flowFilter = {
+  property: "flows",
+  isArray: true
+};
+const foilFilter = {
+  nestedProperty: "foiling",
+  property: "printings",
+  isArray: true
+};
+const fuseFilter = {
+  property: "fusions",
+  isArray: true
+};
+const intellectFilter = {
+  property: "intellect",
+  isNumber: true
+};
+const keywordFilter = {
+  property: "keywords",
+  isArray: true
+  // partialMatch: true,
+};
+const legalFilter = {
+  property: "n/a",
+  isMeta: true
+};
+const lifeFilter = {
+  property: "life",
+  specialProperty: "specialLife",
+  isNumber: true
+};
+const metaFilter = {
+  property: "meta",
+  isArray: true
+};
+const nameFilter = {
+  property: "name",
+  isString: true,
+  partialMatch: true
+};
+const pitchFilter = {
+  property: "pitch",
+  isNumber: true
+};
+const powerFilter = {
+  property: "power",
+  specialProperty: "specialPower",
+  isNumber: true
+};
+const setIdentifiersFilter = {
+  property: "setIdentifiers",
+  isArray: true,
+  partialMatch: true
+};
+const rarityFilter = {
+  property: "n/a",
+  isMeta: true
+};
+const referencedByFilter = {
+  property: "n/a"
+};
+const referencesFilter = {
+  property: "n/a"
+};
+const setFilter = {
+  property: "sets",
+  isArray: true,
+  partialMatch: true
+};
+const shorthandsFilter = {
+  property: "shorthands",
+  isArray: true,
+  partialMatch: true
+};
+const specializationsFilter = {
+  property: "specializations",
+  isArray: true,
+  partialMatch: true
+};
+const subtypeFilter = {
+  property: "subtypes",
+  isArray: true
+};
+const typeFilter = {
+  property: "types",
+  isArray: true
+};
+const talentFilter = {
+  property: "talents",
+  isArray: true
+};
+const textFilter = {
+  property: "functionalText",
+  isString: true,
+  partialMatch: true
+};
+const traitFilter = {
+  property: "traits",
+  isArray: true,
+  partialMatch: true
+};
+const typeTextFilter = {
+  property: "typeText",
+  isString: true,
+  partialMatch: true
+};
+const treatmentFilter = {
+  nestedProperty: "treatments",
+  property: "printings",
+  isArray: true,
+  isNestedPropertyArray: true
+};
+const filtersToCardPropertyMappings = {
+  arcane: arcaneFilter,
+  a: artistFilter,
+  artist: artistFilter,
+  art: artistFilter,
+  attack: powerFilter,
+  b: defenseFilter,
+  block: defenseFilter,
+  banned: bannedFilter,
+  bond: bondFilter,
+  bonds: bondFilter,
+  c: classFilter,
+  class: classFilter,
+  chain: chainFilter,
+  co: costFilter,
+  cost: costFilter,
+  color: pitchFilter,
+  d: defenseFilter,
+  def: defenseFilter,
+  defense: defenseFilter,
+  flow: flowFilter,
+  flows: flowFilter,
+  f: fuseFilter,
+  fusion: fuseFilter,
+  foil: foilFilter,
+  foiling: foilFilter,
+  i: intellectFilter,
+  intellect: intellectFilter,
+  is: metaFilter,
+  k: keywordFilter,
+  keyword: keywordFilter,
+  l: legalFilter,
+  legal: legalFilter,
+  hero: legalFilter,
+  li: lifeFilter,
+  life: lifeFilter,
+  meta: metaFilter,
+  n: nameFilter,
+  name: nameFilter,
+  p: pitchFilter,
+  pitch: pitchFilter,
+  pwr: powerFilter,
+  pow: powerFilter,
+  power: powerFilter,
+  print: setIdentifiersFilter,
+  r: rarityFilter,
+  rarity: rarityFilter,
+  referencedby: referencedByFilter,
+  references: referencesFilter,
+  rf: bannedFilter,
+  s: setFilter,
+  set: setFilter,
+  short: shorthandsFilter,
+  shorthand: shorthandsFilter,
+  shorthands: shorthandsFilter,
+  sp: specializationsFilter,
+  spec: specializationsFilter,
+  specialization: specializationsFilter,
+  specializations: specializationsFilter,
+  st: subtypeFilter,
+  subtype: subtypeFilter,
+  t: typeFilter,
+  type: typeFilter,
+  tal: talentFilter,
+  talent: talentFilter,
+  text: textFilter,
+  trait: traitFilter,
+  treat: treatmentFilter,
+  treatment: treatmentFilter,
+  var: treatmentFilter,
+  variation: treatmentFilter,
+  x: typeTextFilter
+};
+const punctuationOverrides = [
+  {
+    text: Release.ClassicBattlesRhinarDorinthea.toLowerCase(),
+    override: Release.ClassicBattlesRhinarDorinthea.toLowerCase().replaceAll(
+      PUNCTUATION,
+      ""
+    )
+  }
+];
+const getSearchCriteria = (text) => {
+  const searchCriteria = [];
+  let rawSearchCriteria = text.replaceAll("\u201D", '"');
+  for (const { text: text2, override } of punctuationOverrides) {
+    if (rawSearchCriteria.includes(text2)) {
+      rawSearchCriteria = rawSearchCriteria.replace(text2, override);
+    }
+  }
+  const matchingAbbreviation = getAbbreviation(rawSearchCriteria)?.card;
+  if (matchingAbbreviation) {
+    searchCriteria.push(rawSearchCriteria);
+  } else {
+    const splitSearchCriteria = rawSearchCriteria.split(/[ ]+/);
+    let combinedSearchCriteria = "";
+    let combinedQuoteCount = 0;
+    for (const criteria of splitSearchCriteria) {
+      if (combinedQuoteCount === 2) {
+        searchCriteria.push(combinedSearchCriteria.trim().replaceAll('"', ""));
+        combinedSearchCriteria = "";
+        combinedQuoteCount = 0;
+      }
+      if (combinedQuoteCount < 2 && criteria.split('"').length === 2) {
+        combinedSearchCriteria += " " + criteria;
+        combinedQuoteCount++;
+      } else if (combinedQuoteCount === 0 && combinedSearchCriteria === "") {
+        searchCriteria.push(criteria);
+      } else if (combinedQuoteCount === 1) {
+        combinedSearchCriteria += " " + criteria;
+      }
+    }
+    if (combinedQuoteCount === 2) {
+      searchCriteria.push(combinedSearchCriteria.trim().replaceAll('"', ""));
+      combinedSearchCriteria = "";
+      combinedQuoteCount = 0;
+    }
+  }
+  return searchCriteria;
+};
+const getKeywordsAndAppliedFiltersFromText = (text, cards, additionalHeroes = [], additionalSets = []) => {
+  let expandedText = text.trim().toLowerCase();
+  for (const { expanded: filters, shorthands } of multiWordShorthands) {
+    for (const shorthand of shorthands) {
+      if (expandedText.includes(shorthand)) {
+        expandedText = expandedText.replace(shorthand, filters.join(" "));
+        break;
+      }
+    }
+  }
+  for (const [set, setIdentifiers] of Object.entries(
+    setToSetIdentifierMappings
+  )) {
+    if (expandedText.includes(set.toLowerCase())) {
+      expandedText = expandedText.replace(set.toLowerCase(), setIdentifiers[0]);
+    }
+  }
+  const rawSearchCriteria = getSearchCriteria(expandedText);
+  const searchCriteria = [];
+  for (const criteria of rawSearchCriteria) {
+    const expanded = singleWordShorthands.find(
+      ({ shorthands }) => shorthands.includes(criteria)
+    );
+    if (expanded && !expanded.isCardProperty) {
+      searchCriteria.push(...expanded.expanded);
+    } else {
+      searchCriteria.push(criteria);
+    }
+  }
+  let appliedFilters = [];
+  let artists = [];
+  let keywords = [];
+  let foilings = [];
+  let isExpansionSlot = false;
+  let prints = [];
+  let rarities = [];
+  let releases = [];
+  let treatments = [];
+  for (const criteria of searchCriteria) {
+    if (hasFilter(criteria)) {
+      const [unparsedFilterKey, unparsedFilterValue] = criteria.split(":");
+      let { modifier, values, isAnd, isOr } = getFilterValuesAndModifier(unparsedFilterValue);
+      let { filterKey, isExcluded, isOptional, isMeta } = getFilterKeyAndExcludedOrOptional(unparsedFilterKey);
+      if (isMeta) {
+        if (["rarity", "r"].includes(filterKey)) {
+          const rarityValues = getRarityValuesFromText(values);
+          if (!isExcluded) {
+            rarities = [...rarityValues];
+          }
+          values = rarityValues.map((s) => s.toLowerCase());
+        }
+        if (["legal", "l", "hero"].includes(filterKey)) {
+        }
+        appliedFilters.push(
+          ...getMetaFilters(
+            isExcluded,
+            isOptional,
+            filterKey,
+            values,
+            modifier,
+            additionalHeroes
+          )
+        );
+      } else {
+        if (["chain"].includes(filterKey)) {
+          const getName = (card) => card.name.toLowerCase().replaceAll(PUNCTUATION, "");
+          const relatedCardNames = values.map((name) => getCardByName(name, cards)).filter((card) => !!card).map(getName);
+          const names = new Set(relatedCardNames);
+          filterKey = "name";
+          isOr = true;
+          let limit = 20;
+          let counter = 0;
+          const addToSetAndRelated = (card) => {
+            if (!card.types.includes(Type.Hero)) {
+              const name = getName(card);
+              names.add(name);
+              if (!relatedCardNames.includes(name)) {
+                relatedCardNames.push(name);
+              }
+            }
+          };
+          for (const relatedCardName of relatedCardNames) {
+            if (counter > limit) {
+              break;
+            }
+            const { referencedBy, references } = getRelatedCardsByName(
+              relatedCardName,
+              cards
+            );
+            references.forEach(addToSetAndRelated);
+            if (counter === 0) {
+              referencedBy.forEach(addToSetAndRelated);
+            }
+            counter++;
+          }
+          values = Array.from(names);
+        } else if (["referencedby", "references"].includes(filterKey)) {
+          const originalKey = filterKey;
+          const relatedCardNames = [...values].filter((value) => !!value);
+          values = [];
+          filterKey = "name";
+          isOr = true;
+          for (const relatedCardName of relatedCardNames) {
+            const { referencedBy, references } = getRelatedCardsByName(
+              relatedCardName,
+              cards
+            );
+            if (["referencedby"].includes(originalKey)) {
+              values.push(
+                ...references.map(
+                  ({ name }) => name.toLowerCase().replaceAll(PUNCTUATION, "")
+                )
+              );
+            } else if (["references"].includes(originalKey)) {
+              values.push(
+                ...referencedBy.map(
+                  ({ name }) => name.toLowerCase().replaceAll(PUNCTUATION, "")
+                )
+              );
+            }
+          }
+        } else if (["art", "artist"].includes(filterKey)) {
+          artists = values;
+        } else if (["print", "prints", "printing", "printings"].includes(filterKey)) {
+          prints = values;
+        } else if (["is", "meta"].includes(filterKey)) {
+          const metaValues = getMetaValuesFromText(values);
+          values = metaValues.map(
+            (v) => v.toLowerCase().replaceAll(PUNCTUATION, "")
+          );
+          if (metaValues.includes(Meta.Expansion) && !isExcluded) {
+            isExpansionSlot = true;
+          }
+        } else if (["foiling", "foil"].includes(filterKey)) {
+          foilings = getFoilingValuesFromText(values);
+          values = foilings.map((f) => f.toLowerCase());
+        } else if (["treat", "treatment", "var", "variation"].includes(filterKey)) {
+          treatments = getTreatmentValuesFromText(values);
+          values = treatments.map((t) => t.toLowerCase());
+        } else if (["set", "s"].includes(filterKey)) {
+          releases = getReleasesFromRawValues(values, additionalSets);
+          values = releases.map(
+            (s) => s.toLowerCase().replaceAll(PUNCTUATION, "")
+          );
+        } else if (["pitch", "p", "color"].includes(filterKey)) {
+          values = getPitchValuesFromText(values);
+        }
+        if (filtersToCardPropertyMappings[filterKey]) {
+          appliedFilters.push({
+            filterToPropertyMapping: filtersToCardPropertyMappings[filterKey],
+            values,
+            isAnd,
+            isOr,
+            modifier,
+            isExcluded,
+            isOptional
+          });
+        }
+      }
+    } else if (criteria) {
+      const expanded = getAbbreviation(criteria)?.card;
+      const metaFilters = getExcludedMetaFilters(criteria);
+      if (expanded) {
+        keywords.push(`"${expanded.toLowerCase().replace(PUNCTUATION, "")}"`);
+      } else if (metaFilters && metaFilters.length > 0) {
+        appliedFilters.push(...metaFilters);
+      } else {
+        keywords.push(criteria.replace(PUNCTUATION, ""));
+      }
+    }
+  }
+  return {
+    appliedFilters,
+    attributes: {
+      artists,
+      foilings,
+      isExpansionSlot,
+      prints,
+      rarities,
+      releases,
+      treatments
+    },
+    keywords
+  };
+};
+const getReleasesFromRawValues = (rawValues, additionalSets = []) => {
+  const releases = [];
+  for (const rawValue of rawValues) {
+    releases.push(...getMatchingReleasesFromRawValue(rawValue, additionalSets));
+  }
+  return releases;
+};
+const getMatchingReleasesFromRawValue = (rawValue, additionalSets = []) => {
+  const releases = [];
+  const setFromValue = Object.values(Release).find(
+    (release) => release.toLowerCase().replaceAll(PUNCTUATION, "") === rawValue
+  );
+  if (setFromValue) {
+    releases.push(setFromValue);
+  }
+  if (releases.length === 0) {
+    const setFromSetIdentifier = setIdentifierToSetMappings[rawValue];
+    if (setFromSetIdentifier) {
+      releases.push(setFromSetIdentifier);
+    }
+  }
+  if (releases.length === 0) {
+    const setsFromPartialValue = Object.values(Release).filter(
+      (release) => release.toLowerCase().includes(rawValue)
+    );
+    if (setsFromPartialValue.length > 0) {
+      releases.push(...setsFromPartialValue);
+    }
+  }
+  if (releases.length === 0) {
+    const additionalSetFromValue = additionalSets.find(
+      (additionalSet) => additionalSet.toLowerCase().replaceAll(PUNCTUATION, "") === rawValue
+    );
+    if (additionalSetFromValue) {
+      releases.push(additionalSetFromValue);
+    }
+  }
+  return releases;
+};
+const pitchValuesMapping = {
+  blue: 3,
+  yellow: 2,
+  red: 1,
+  white: 0
+};
+const getPitchValuesFromText = (rawValues) => {
+  const values = [];
+  for (const rawValue of rawValues) {
+    if (pitchValuesMapping[rawValue] || pitchValuesMapping[rawValue] === 0) {
+      values.push(pitchValuesMapping[rawValue].toString());
+    } else {
+      values.push(rawValue);
+    }
+  }
+  return values;
+};
+const metaValuesMapping = {
+  exp: Meta.Expansion,
+  expansion: Meta.Expansion,
+  expansionSlot: Meta.Expansion,
+  rainbow: Meta.Rainbow
+};
+const getMetaValuesFromText = (rawValues) => {
+  const values = [];
+  for (const rawValue of rawValues) {
+    if (metaValuesMapping[rawValue]) {
+      values.push(metaValuesMapping[rawValue]);
+    }
+  }
+  return values;
+};
+const foilingValuesMapping = {
+  r: Foiling.Rainbow,
+  rf: Foiling.Rainbow,
+  rainbow: Foiling.Rainbow,
+  c: Foiling.Cold,
+  cf: Foiling.Cold,
+  cold: Foiling.Cold,
+  g: Foiling.Gold,
+  gf: Foiling.Gold,
+  gold: Foiling.Gold
+};
+const getFoilingValuesFromText = (rawValues) => {
+  const values = [];
+  for (const rawValue of rawValues) {
+    if (foilingValuesMapping[rawValue]) {
+      values.push(foilingValuesMapping[rawValue]);
+    }
+  }
+  return values;
+};
+const treatmentValuesMapping = {
+  ...Object.values(Treatment).reduce((obj, treatment) => {
+    obj[treatment.toLowerCase()] = treatment;
+    return obj;
+  }, {}),
+  ...{
+    aa: Treatment.AA,
+    alt: Treatment.AA,
+    "alt art": Treatment.AA,
+    ab: Treatment.AB,
+    "alt border": Treatment.AB,
+    at: Treatment.AT,
+    "alt text": Treatment.AT,
+    // ds: Treatment.DS,
+    // "double sided": Treatment.DS,
+    ea: Treatment.EA,
+    extended: Treatment.EA,
+    "extended art": Treatment.EA,
+    fa: Treatment.FA,
+    full: Treatment.FA,
+    "full art": Treatment.FA
+  }
+};
+const getTreatmentValuesFromText = (rawValues) => {
+  const values = [];
+  for (const rawValue of rawValues) {
+    if (treatmentValuesMapping[rawValue]) {
+      values.push(treatmentValuesMapping[rawValue]);
+    } else if (!!Treatment[rawValue.toUpperCase()]) {
+      values.push(Treatment[rawValue.toUpperCase()]);
+    }
+  }
+  return values;
+};
+const RARITY_VALUES_MAPPING = {
+  b: Rarity.Basic,
+  c: Rarity.Common,
+  f: Rarity.Fabled,
+  l: Rarity.Legendary,
+  m: Rarity.Majestic,
+  p: Rarity.Promo,
+  r: Rarity.Rare,
+  s: Rarity.SuperRare,
+  t: Rarity.Token,
+  v: Rarity.Marvel
+};
+const getRarityValuesFromText = (rawValues) => {
+  const values = [];
+  for (const rawValue of rawValues) {
+    if (RARITY_VALUES_MAPPING[rawValue]) {
+      values.push(RARITY_VALUES_MAPPING[rawValue]);
+    } else {
+      values.push(rawValue);
+    }
+  }
+  return values;
+};
+const getFilterValuesAndModifier = (unparsedFilterValue) => {
+  const values = [];
+  let isAnd, isOr;
+  const modifier = availableModifiers.find(
+    (modifier2) => unparsedFilterValue.includes(modifier2)
+  );
+  if (modifier) {
+    const [, rawValue] = unparsedFilterValue.split(modifier);
+    if (filterIsAnd(rawValue)) {
+      isAnd = true;
+      values.push(
+        ...rawValue.trim().split("+").map((value) => value.replace(PUNCTUATION, ""))
+      );
+    } else if (filterIsOr(rawValue)) {
+      isOr = true;
+      values.push(
+        ...rawValue.trim().split(",").map((value) => value.replace(PUNCTUATION, ""))
+      );
+    } else {
+      values.push(rawValue.trim().replace(PUNCTUATION, ""));
+    }
+  } else {
+    if (filterIsAnd(unparsedFilterValue)) {
+      isAnd = true;
+      values.push(
+        ...unparsedFilterValue.trim().split("+").map((value) => value.replace(PUNCTUATION, ""))
+      );
+    } else if (filterIsOr(unparsedFilterValue)) {
+      isOr = true;
+      values.push(
+        ...unparsedFilterValue.trim().split(",").map((value) => value.replace(PUNCTUATION, ""))
+      );
+    } else {
+      if (unparsedFilterValue.startsWith('"') && unparsedFilterValue.endsWith('"')) {
+        values.push(
+          unparsedFilterValue.trim().replaceAll('"', "").replace(PUNCTUATION, "")
+        );
+      } else {
+        values.push(unparsedFilterValue.trim().replace(PUNCTUATION, ""));
+      }
+    }
+  }
+  return { modifier, values, isAnd, isOr };
+};
+const getFilterKeyAndExcludedOrOptional = (unparsedFilterKey) => {
+  const exclusion = getExclusion(unparsedFilterKey);
+  if (exclusion) {
+    const [, filterKey] = unparsedFilterKey.split(exclusion);
+    return {
+      filterKey,
+      isExcluded: true,
+      isOptional: false,
+      isMeta: filterIsMeta(filterKey)
+    };
+  } else {
+    return {
+      filterKey: unparsedFilterKey,
+      isExcluded: false,
+      isOptional: false,
+      isMeta: filterIsMeta(unparsedFilterKey)
+    };
+  }
+};
+const hasFilter = (text) => text.indexOf(":") >= 0;
+const filterIsAnd = (text) => text.indexOf("+") >= 0;
+const filterIsOr = (text) => text.indexOf(",") >= 0;
+const filterIsMeta = (filterKey) => !!filtersToCardPropertyMappings[filterKey]?.isMeta;
+const getExclusion = (text) => availableExclusions.find((exclusion) => text.includes(exclusion))?.slice(0, 1);
+export {
+  RARITY_VALUES_MAPPING,
+  availableExclusions,
+  availableModifiers,
+  filtersToCardPropertyMappings,
+  getKeywordsAndAppliedFiltersFromText
+};

package/dist/helpers.js

@@ -0,0 +1,15 @@
+import { PUNCTUATION } from "./constants";
+const getCardByName = (name, cards) => {
+  let card = cards.find((card2) => getCleanText(card2.name) === name);
+  if (!card) {
+    card = cards.find((card2) => getCleanText(card2.name).includes(name));
+  }
+  return card;
+};
+const getCleanText = (text) => getNormalizedText(text.toLowerCase().trim().replace(PUNCTUATION, ""));
+const getNormalizedText = (text) => text.normalize("NFD").replace(/\p{Diacritic}/gu, "");
+export {
+  getCardByName,
+  getCleanText,
+  getNormalizedText
+};