@flesh-and-blood/search 5.3.0 → 5.4.0

package/dist/queryParse.js

@@ -2,7 +2,6 @@ import {
   Release,
   setToSetIdentifierMappings
 } from "@flesh-and-blood/types";
-import { getAbbreviation } from "./abbreviations.js";
 import { PUNCTUATION } from "./constants.js";
 import {
   aliasesByFilterCategory,
@@ -55,7 +54,7 @@ const setNameInSetFilterPattern = new RegExp(
   )}):(?:[^\\s]*[,+])?"?)(${setNamesLongestFirst})(?="?(?:[,+]|\\s|$))`,
   "g"
 );
-const getPreparedQuery = (text, index) => {
+const getPreparedText = (text, index) => {
   let preparedText = text.trim().toLowerCase();
   for (const smartQuote of SMART_DOUBLE_QUOTES) {
     preparedText = preparedText.replaceAll(smartQuote, '"');
@@ -85,12 +84,7 @@ const getPreparedQuery = (text, index) => {
       preparedText = preparedText.replace(punctuatedName, override);
     }
   }
-  return {
-    // A query that is nothing but a card's abbreviation names that card whole,
-    // so its own spaces and commas are not separators.
-    isWholeQueryAbbreviation: !!getAbbreviation(preparedText)?.card,
-    text: preparedText
-  };
+  return preparedText;
 };
 const getExpandedTokens = (token) => {
   const matchingShorthand = singleWordShorthands.find(
@@ -102,13 +96,9 @@ const getExpandedTokens = (token) => {
     tokens: isExpanded ? matchingShorthand.expanded : [token]
   };
 };
-const getQueryTermSpans = ({
-  isWholeQueryAbbreviation,
-  text
-}) => {
+const getQueryTermSpans = (text) => {
   const termSpans = [];
-  const tokenSpans = isWholeQueryAbbreviation ? [{ end: text.length, start: 0, token: text }] : getQueryTokenSpans(text);
-  for (const { end, start, token } of tokenSpans) {
+  for (const { end, start, token } of getQueryTokenSpans(text)) {
     const { isExpanded, tokens } = getExpandedTokens(token);
     for (const expandedToken of tokens) {
       termSpans.push({ end, isExpanded, start, token: expandedToken });
@@ -146,7 +136,7 @@ const getParsedQuery = (text, index, {
   additionalSets = [],
   today = getTodayAsReleaseDate()
 } = {}) => {
-  const preparedQuery = getPreparedQuery(text, index);
+  const preparedText = getPreparedText(text, index);
   const context = {
     additionalHeroes,
     additionalSets,
@@ -166,7 +156,7 @@ const getParsedQuery = (text, index, {
   const keywords = [];
   const nodes = [];
   const unresolvedFilters = [];
-  for (const termSpan of getQueryTermSpans(preparedQuery)) {
+  for (const termSpan of getQueryTermSpans(preparedText)) {
     const filterToken = getQueryFilterToken(termSpan.token) || getIncompleteFilterToken(termSpan.token);
     if (filterToken) {
       const { isAndList, isExcluded, key, valueText } = filterToken;
@@ -225,13 +215,8 @@ const getParsedQuery = (text, index, {
       const { end, start, token } = termSpan;
       nodes.push({ end, isFilter: false, start, token });
       const freeText = getUnquotedValue(termSpan.token);
-      const abbreviatedCard = getAbbreviation(freeText)?.card;
       const excludedMetaFilters = getExcludedMetaFilters(freeText);
-      if (abbreviatedCard) {
-        keywords.push(
-          `"${abbreviatedCard.toLowerCase().replace(PUNCTUATION, "")}"`
-        );
-      } else if (excludedMetaFilters.length > 0) {
+      if (excludedMetaFilters.length > 0) {
         appliedFilters.push(...excludedMetaFilters);
       } else if (freeText) {
         keywords.push(freeText.replace(PUNCTUATION, ""));
@@ -243,7 +228,7 @@ const getParsedQuery = (text, index, {
     attributes,
     keywords,
     nodes,
-    text: preparedQuery.text,
+    text: preparedText,
     unresolvedFilters
   };
 };

package/dist/search.d.ts

@@ -18,7 +18,14 @@ export interface SearchOptions {
      */
     index?: CatalogueIndex;
 }
+/** How the free text named cards other than by their names. */
+export interface SearchAlias {
+    kind: "nickname" | "initials";
+    text: string;
+}
 export interface SearchResults {
+    /** Set when the free text was a nickname or the initials of the cards found. */
+    alias?: SearchAlias;
     appliedFilters: AppliedFilter[];
     keywords: string[];
     attributes: QueryAttributes;
@@ -35,9 +42,15 @@ declare class Search {
     private cards;
     private fuse;
     private index;
+    private poolCardByCardIdentifier;
     constructor(cards: DoubleSidedCard[], options?: SearchOptions);
     constructor(cards: DoubleSidedCard[], additionalHeroes?: Hero[], additionalSets?: Release[]);
     private getFuse;
+    /**
+     * The pool's own copies of index cards, dropping any the pool lacks, so a pool
+     * searched out of a larger catalogue returns its cards alone.
+     */
+    private getPoolCards;
     search: (text: string, includeMemes?: boolean) => SearchResults;
 }
 export default Search;

package/dist/search.js

@@ -11,7 +11,11 @@ import {
   getParsedQuery
 } from "./queryParse.js";
 import { memes } from "./memes.js";
-import { getNormalizedText, getTextWithoutMarkup } from "./helpers.js";
+import {
+  getCleanText,
+  getNormalizedText,
+  getTextWithoutMarkup
+} from "./helpers.js";
 import { FilterProperty } from "./metaFilters.js";
 import { getCatalogueIndex } from "./searchIndex.js";
 const searchOptions = {
@@ -52,27 +56,78 @@ class Search {
       }
       return this.fuse;
     };
+    /**
+     * The pool's own copies of index cards, dropping any the pool lacks, so a pool
+     * searched out of a larger catalogue returns its cards alone.
+     */
+    this.getPoolCards = (indexCards) => {
+      if (!this.poolCardByCardIdentifier) {
+        this.poolCardByCardIdentifier = new Map(
+          this.cards.map((card) => [card.cardIdentifier, card])
+        );
+      }
+      const poolCards = [];
+      for (const { cardIdentifier } of indexCards) {
+        const poolCard = this.poolCardByCardIdentifier.get(cardIdentifier);
+        if (poolCard) {
+          poolCards.push(poolCard);
+        }
+      }
+      return poolCards;
+    };
     this.search = (text, includeMemes) => {
       let results;
+      let alias;
       const { appliedFilters, attributes, keywords, unresolvedFilters } = getParsedQuery(text, this.index, {
         additionalHeroes: this.additionalHeroes,
         additionalSets: this.additionalSets
       });
       const keyword = keywords.join(" ");
       const matchingMemes = includeMemes ? memes.filter((meme) => meme.keyword === keyword) : [];
+      const getFilteredCards = (cardsToFilter) => appliedFilters.length > 0 ? cardsToFilter.filter(
+        (card) => card && filterCard(card, appliedFilters)
+      ) : cardsToFilter;
       if (matchingMemes.length > 0) {
-        results = matchingMemes.map(({ card }) => card);
+        results = getFilteredCards(matchingMemes.map(({ card }) => card));
       } else if (keywords.length) {
-        results = this.getFuse().search(keyword).map((result) => result.item);
-      } else {
-        results = [...this.cards];
-      }
-      if (appliedFilters.length) {
-        results = results.filter(
-          (card) => card && filterCard(card, appliedFilters)
+        const freeText = getCleanText(keyword);
+        const nicknamedCards = this.getPoolCards(
+          this.index.getCardsByNickname(freeText)
+        );
+        const namedCardByCardIdentifier = /* @__PURE__ */ new Map();
+        for (const card of [
+          ...this.getPoolCards(this.index.getCardsByExactName(freeText)),
+          ...nicknamedCards
+        ]) {
+          namedCardByCardIdentifier.set(card.cardIdentifier, card);
+        }
+        const textMatches = this.getFuse().search(keyword).map((result) => result.item).filter(
+          ({ cardIdentifier }) => !namedCardByCardIdentifier.has(cardIdentifier)
         );
+        results = getFilteredCards([
+          ...namedCardByCardIdentifier.values(),
+          ...textMatches
+        ]);
+        const hasNicknamedResult = results.some(
+          (card) => nicknamedCards.includes(card)
+        );
+        if (hasNicknamedResult) {
+          alias = { kind: "nickname", text: freeText };
+        }
+        const canFallBackToInitials = results.length === 0 && keywords.length === 1;
+        if (canFallBackToInitials) {
+          results = getFilteredCards(
+            this.getPoolCards(this.index.getCardsByInitials(freeText))
+          );
+          if (results.length > 0) {
+            alias = { kind: "initials", text: freeText };
+          }
+        }
+      } else {
+        results = getFilteredCards([...this.cards]);
       }
-      if (keywords.length === 0) {
+      const isRankedByText = keywords.length > 0 && alias?.kind !== "initials";
+      if (!isRankedByText) {
         let setIdentifierToSortBy = "";
         const shouldSortByRelease = attributes.releases.length === 1;
         if (shouldSortByRelease) {
@@ -101,18 +156,6 @@ class Search {
             (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 {
@@ -155,6 +198,7 @@ class Search {
       }
       const searchResults = searchResultsWithMatchingPrinting.length > 0 ? searchResultsWithMatchingPrinting : results;
       return {
+        alias,
         appliedFilters,
         attributes,
         keywords,

package/dist/searchIndex.d.ts

@@ -1,4 +1,4 @@
-import { Card, CardRole, DoubleSidedCard } from "@flesh-and-blood/types";
+import { CardRole, DoubleSidedCard } from "@flesh-and-blood/types";
 /**
  * Everything a corpus can be asked about its cards: lookups, the relations the
  * cards carry, and what each card is for. Every relation is identifier-level,
@@ -26,6 +26,18 @@ export interface CatalogueIndex<CardType extends DoubleSidedCard = DoubleSidedCa
      * a fragment of a name the corpus carries finds nothing.
      */
     getCardsByExactName: (name: string) => readonly CardType[];
+    /** Every card carrying the nickname, matched whole, hyphens ignored. */
+    getCardsByNickname: (nickname: string) => readonly CardType[];
+    /**
+     * Every card carrying the type, subtype or trait, matched whole, hyphens
+     * ignored.
+     */
+    getCardsByGroup: (group: string) => readonly CardType[];
+    /**
+     * Every card whose name has the initials, in corpus order, counting a
+     * hyphenated word both as one word and as the words the hyphens join.
+     */
+    getCardsByInitials: (initials: string) => readonly CardType[];
     /**
      * Every artist the corpus credits, each once, ordered by the `en` locale
      * ignoring case and diacritics so a browser and a server agree on the list.
@@ -65,7 +77,3 @@ export interface CatalogueIndex<CardType extends DoubleSidedCard = DoubleSidedCa
 export declare const getCatalogueIndex: <CardType extends DoubleSidedCard = DoubleSidedCard>(cards: readonly CardType[]) => CatalogueIndex<CardType>;
 /** {@link CatalogueIndex.getCardsByName}, as a free function over an index. */
 export declare const getCardsByName: (index: CatalogueIndex, name: string) => readonly DoubleSidedCard[];
-/** The cards naming the card, at every pitch of both. */
-export declare const getCardsReferencing: (index: CatalogueIndex, card: Card) => DoubleSidedCard[];
-/** The cards the card names, at every pitch of both. */
-export declare const getCardsReferencedBy: (index: CatalogueIndex, card: Card) => DoubleSidedCard[];

package/dist/searchIndex.js

@@ -3,7 +3,37 @@ import {
   getCardRole,
   Type
 } from "@flesh-and-blood/types";
-import { getCleanText } from "./helpers.js";
+import { getCleanText, getNormalizedText } from "./helpers.js";
+const MINIMUM_INITIALS_LENGTH = 3;
+const getInitialsOfName = (name) => {
+  const letters = getNormalizedText(name.toLowerCase()).replace(
+    /[^a-z\s-]/g,
+    ""
+  );
+  const initialsOfName = /* @__PURE__ */ new Set();
+  for (const wordBreak of [/[\s-]+/, /\s+/]) {
+    let initials = "";
+    for (const word of letters.split(wordBreak)) {
+      const wordLetters = word.replaceAll("-", "");
+      if (wordLetters) {
+        initials += wordLetters[0];
+      }
+    }
+    if (initials.length >= MINIMUM_INITIALS_LENGTH) {
+      initialsOfName.add(initials);
+    }
+  }
+  return [...initialsOfName];
+};
+const getHyphenFreeKey = (text) => getCleanText(text).replaceAll("-", "");
+const addToCardList = (cardsByKey, key, card) => {
+  const cardsForKey = cardsByKey.get(key);
+  if (cardsForKey) {
+    cardsForKey.push(card);
+  } else {
+    cardsByKey.set(key, [card]);
+  }
+};
 const catalogueIndexByCards = /* @__PURE__ */ new WeakMap();
 const noCards = Object.freeze([]);
 const strayCorpusPosition = Number.MAX_SAFE_INTEGER;
@@ -44,6 +74,9 @@ const getNewCatalogueIndex = (cards) => {
   let creatingCardsByCardIdentifier;
   let cardsByRole;
   let artists;
+  let cardsByNicknameKey;
+  let cardsByGroup;
+  let cardsByInitials;
   const getCardLookups = () => {
     if (!cardLookups) {
       const cardByCardIdentifier = /* @__PURE__ */ new Map();
@@ -132,6 +165,47 @@ const getNewCatalogueIndex = (cards) => {
     const { pitchCycleByCleanedName } = getCardLookups();
     return pitchCycleByCleanedName.get(getCleanText(name)) ?? noCards;
   };
+  const getCardsByNickname = (nickname) => {
+    if (!cardsByNicknameKey) {
+      cardsByNicknameKey = /* @__PURE__ */ new Map();
+      for (const card of cards) {
+        for (const cardNickname of card.nicknames ?? []) {
+          addToCardList(
+            cardsByNicknameKey,
+            getHyphenFreeKey(cardNickname),
+            card
+          );
+        }
+      }
+    }
+    return cardsByNicknameKey.get(getHyphenFreeKey(nickname)) ?? noCards;
+  };
+  const getCardsByGroup = (group) => {
+    if (!cardsByGroup) {
+      cardsByGroup = /* @__PURE__ */ new Map();
+      for (const card of cards) {
+        for (const cardGroup of [
+          ...card.types,
+          ...card.subtypes,
+          ...card.traits ?? []
+        ]) {
+          addToCardList(cardsByGroup, getHyphenFreeKey(cardGroup), card);
+        }
+      }
+    }
+    return cardsByGroup.get(getHyphenFreeKey(group)) ?? noCards;
+  };
+  const getCardsByInitials = (initials) => {
+    if (!cardsByInitials) {
+      cardsByInitials = /* @__PURE__ */ new Map();
+      for (const card of cards) {
+        for (const initialsOfName of getInitialsOfName(card.name)) {
+          addToCardList(cardsByInitials, initialsOfName, card);
+        }
+      }
+    }
+    return cardsByInitials.get(initials) ?? noCards;
+  };
   const getArtists = () => {
     if (!artists) {
       const creditedArtists = /* @__PURE__ */ new Set();
@@ -202,6 +276,9 @@ const getNewCatalogueIndex = (cards) => {
     getPitchCycle,
     getCardsByName: getCardsByName2,
     getCardsByExactName,
+    getCardsByNickname,
+    getCardsByGroup,
+    getCardsByInitials,
     getArtists,
     getOppositeSide,
     getReferences,
@@ -221,34 +298,8 @@ const getCatalogueIndex = (cards) => {
   }
   return catalogueIndex;
 };
-const getPitchCycleOfCard = (index, card) => index.getPitchCycle(card.cardIdentifier);
 const getCardsByName = (index, name) => index.getCardsByName(name);
-const getCardsWithPitchSiblings = (index, cards) => {
-  const cardByCardIdentifier = /* @__PURE__ */ new Map();
-  for (const card of cards) {
-    for (const pitch of getPitchCycleOfCard(index, card)) {
-      cardByCardIdentifier.set(pitch.cardIdentifier, pitch);
-    }
-  }
-  return index.getCardsInCorpusOrder([...cardByCardIdentifier.values()]);
-};
-const getCardsReferencing = (index, card) => {
-  const referencingCards = [];
-  for (const pitch of getPitchCycleOfCard(index, card)) {
-    referencingCards.push(...index.getReferencedBy(pitch.cardIdentifier));
-  }
-  return getCardsWithPitchSiblings(index, referencingCards);
-};
-const getCardsReferencedBy = (index, card) => {
-  const referencedCards = [];
-  for (const pitch of getPitchCycleOfCard(index, card)) {
-    referencedCards.push(...index.getReferences(pitch.cardIdentifier));
-  }
-  return getCardsWithPitchSiblings(index, referencedCards);
-};
 export {
   getCardsByName,
-  getCardsReferencedBy,
-  getCardsReferencing,
   getCatalogueIndex
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@flesh-and-blood/search",
   "description": "TypeScript search engine for Flesh and Blood cards",
-  "version": "5.3.0",
+  "version": "5.4.0",
   "type": "module",
   "sideEffects": false,
   "main": "dist/index.cjs",
@@ -47,7 +47,7 @@
     "@flesh-and-blood/types": "^5.0.0"
   },
   "devDependencies": {
-    "@flesh-and-blood/cards": "^5.3.0",
+    "@flesh-and-blood/cards": "^5.4.0",
     "@flesh-and-blood/types": "^5.3.0",
     "@types/node": "^26.6.3",
     "esbuild": "^0.28.2",
@@ -75,5 +75,5 @@
     "FAB",
     "FABTCG"
   ],
-  "gitHead": "8bbc088b56ea541fccbc3885bbf2edcd3ea9983f"
+  "gitHead": "b9859b97493dfa6b6d0990be6b19341ec54a315e"
 }

package/dist/abbreviations.d.ts

@@ -1,9 +0,0 @@
-import { Card } from "@flesh-and-blood/types";
-export interface Abbreviation {
-    abbreviations: string[];
-    card: string;
-    isHidden?: boolean;
-}
-export declare const getAbbreviation: (abbreviation: string) => Abbreviation | undefined;
-export declare const getAbbreviationByCard: (c: Card) => Abbreviation | undefined;
-export declare const abbreviations: Abbreviation[];