@flesh-and-blood/search 5.0.15 → 5.0.16

package/dist/filterMappings.d.ts

@@ -55,6 +55,15 @@ export declare const FilterKind: {
 export type FilterKind = (typeof FilterKind)[keyof typeof FilterKind];
 export type Modifier = ">=" | ">" | "<=" | "<";
 export declare const availableModifiers: Modifier[];
+/**
+ * A value written against a filter, carrying the comparison written in front of
+ * it. Each value takes its own, so one term can ask for a cost of 1 or a cost
+ * above 2.
+ */
+export interface FilterValue {
+    modifier?: Modifier;
+    value: string;
+}
 export type Exclusion = "!" | "-";
 export declare const availableExclusions: Exclusion[];
 /** The card field a mapping reads. */
@@ -62,7 +71,7 @@ export type CardPropertyName = keyof Card;
 /**
  * The property of a mapping that reads no card field: a meta filter expands
  * into other filters before any card is read, and a relation filter matches
- * the identifiers the parser resolved.
+ * the identifiers the parse resolved.
  */
 export declare const NO_CARD_PROPERTY = "n/a";
 /**
@@ -71,7 +80,7 @@ export declare const NO_CARD_PROPERTY = "n/a";
  */
 export type CardSpecialPropertyName = "specialArcane" | "specialCost" | "specialDefense" | "specialLife" | "specialPower";
 /**
- * How a card property is read and compared. The parser builds some of these
+ * How a card property is read and compared. The parse builds some of these
  * for itself, expanding a meta filter or matching the cards a relation filter
  * resolved, and those name no filter key, so they carry no grammar.
  */
@@ -103,6 +112,38 @@ export interface CardPropertyMapping {
     partialMatch?: boolean;
     specialProperty?: CardSpecialPropertyName;
 }
+/**
+ * A filter a query asked for: the mapping to match cards against, the values
+ * to match, and how they combine. The parse builds these; the matcher reads
+ * them.
+ */
+export interface AppliedFilter {
+    filterToPropertyMapping: CardPropertyMapping;
+    values: string[];
+    /**
+     * The same values with the comparison each was written behind, for the
+     * filters whose values a query writes directly. Absent where the parse
+     * resolved a value into others (a format into its heroes, a rarity into the
+     * ones ranked above it), which no comparison reaches.
+     */
+    filterValues?: FilterValue[];
+    /**
+     * The same strings as `values`, for filters whose match is exact membership
+     * rather than a comparison, so a card costs one lookup instead of a scan.
+     * Consumers read `values`; this is the matcher's copy.
+     */
+    valuesSet?: Set<string>;
+    isAnd?: boolean;
+    isOr?: boolean;
+    modifier?: Modifier;
+    isExcluded?: boolean;
+    /**
+     * Set by a consumer building filters of its own, never by the parse. A
+     * filter carrying it narrows nothing.
+     */
+    isOptional?: boolean;
+    cardTypes?: string[];
+}
 /**
  * A mapping a filter key names, and what the grammar says about it: which
  * filter it is, the spelling it is named by, how its values are read, and the
@@ -124,7 +165,7 @@ export interface FilterToPropertyMapping extends CardPropertyMapping {
     /**
      * The values a card carries for this filter, as the enum they come from:
      * what a dialog offers as options and what a hint draws a suggestion from.
-     * It is not the set of spellings the parser accepts, which is wider, since
+     * It is not the set of spellings the parse accepts, which is wider, since
      * the foiling, treatment, rarity, legality and meta resolvers each take
      * abbreviations of their own. A filter reading free text (`artist`, `name`,
      * `text`, `typetext`), a card name (`chain`, `references`, `referencedby`),
@@ -486,6 +527,30 @@ export declare const filtersToCardPropertyMappings: {
         isArray: true;
         partialMatch: true;
     };
+    printing: {
+        category: "print";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "setIdentifiers";
+        isArray: true;
+        partialMatch: true;
+    };
+    printings: {
+        category: "print";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "setIdentifiers";
+        isArray: true;
+        partialMatch: true;
+    };
+    prints: {
+        category: "print";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "setIdentifiers";
+        isArray: true;
+        partialMatch: true;
+    };
     r: {
         category: "rarity";
         canonicalAlias: string;
@@ -651,6 +716,14 @@ export declare const filtersToCardPropertyMappings: {
         property: "talents";
         isArray: true;
     };
+    talents: {
+        category: "talent";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Talent[];
+        property: "talents";
+        isArray: true;
+    };
     text: {
         category: "text";
         canonicalAlias: string;
@@ -741,7 +814,23 @@ export declare const filtersToCardPropertyMappings: {
 export declare const filtersToCardPropertyMappingsByKey: {
     [key: string]: FilterToPropertyMapping | undefined;
 };
-/** Case-folded, so a key answers however it was capitalised. */
+/**
+ * The filter a key names, however it was capitalised, and nothing where the
+ * key names none.
+ */
+export declare const getFilterMapping: (key: string) => FilterToPropertyMapping | undefined;
 export declare const getFilterCategory: (key: string) => FilterCategory | undefined;
 /** Every spelling a query can name each filter by. */
 export declare const aliasesByFilterCategory: Record<FilterCategory, readonly string[]>;
+/**
+ * Whether the values a filter declares hold the one written against it,
+ * however that one was cased and punctuated.
+ */
+export declare const getIsValueInFilterVocabulary: (category: FilterCategory, value: string) => boolean;
+/**
+ * The spelling that names the filter a value was meant for, where exactly one
+ * filter other than the one it was written against declares it. Several
+ * filters declaring it is a choice for the reader to make rather than one to
+ * make on their behalf.
+ */
+export declare const getSuggestedFilterKey: (category: FilterCategory, values: string[]) => string | undefined;

package/dist/filterMappings.js

@@ -17,6 +17,7 @@ import {
   Treatment,
   Type
 } from "@flesh-and-blood/types";
+import { getNormalizedFilterValue } from "./helpers.js";
 import { getLookupWithoutInheritedKeys } from "./lookups.js";
 const FilterCategory = {
   Arcane: "arcane",
@@ -390,6 +391,9 @@ const filtersToCardPropertyMappings = {
   pow: powerFilter,
   power: powerFilter,
   print: setIdentifiersFilter,
+  printing: setIdentifiersFilter,
+  printings: setIdentifiersFilter,
+  prints: setIdentifiersFilter,
   r: rarityFilter,
   rarity: rarityFilter,
   referencedby: referencedByFilter,
@@ -410,6 +414,7 @@ const filtersToCardPropertyMappings = {
   type: typeFilter,
   tal: talentFilter,
   talent: talentFilter,
+  talents: talentFilter,
   text: textFilter,
   trait: traitFilter,
   treat: treatmentFilter,
@@ -421,7 +426,8 @@ const filtersToCardPropertyMappings = {
   year: yearFilter
 };
 const filtersToCardPropertyMappingsByKey = getLookupWithoutInheritedKeys(filtersToCardPropertyMappings);
-const getFilterCategory = (key) => filtersToCardPropertyMappingsByKey[key.toLowerCase()]?.category;
+const getFilterMapping = (key) => filtersToCardPropertyMappingsByKey[key.toLowerCase()];
+const getFilterCategory = (key) => getFilterMapping(key)?.category;
 const getAliasesByFilterCategory = () => {
   const aliasesByCategory = /* @__PURE__ */ Object.create(null);
   for (const [alias, { category }] of Object.entries(
@@ -437,6 +443,53 @@ const getAliasesByFilterCategory = () => {
   return aliasesByCategory;
 };
 const aliasesByFilterCategory = getAliasesByFilterCategory();
+const getFilterMappingsByVocabularyValue = () => {
+  const mappingsByVocabularyValue = /* @__PURE__ */ Object.create(null);
+  const walkedMappings = /* @__PURE__ */ new Set();
+  const mappings = Object.values(
+    filtersToCardPropertyMappings
+  );
+  for (const mapping of mappings) {
+    const { vocabulary } = mapping;
+    if (vocabulary && !walkedMappings.has(mapping)) {
+      walkedMappings.add(mapping);
+      for (const vocabularyValue of vocabulary) {
+        const normalizedValue = getNormalizedFilterValue(vocabularyValue);
+        const mappingsHoldingValue = mappingsByVocabularyValue[normalizedValue];
+        if (mappingsHoldingValue) {
+          mappingsHoldingValue.push(mapping);
+        } else {
+          mappingsByVocabularyValue[normalizedValue] = [mapping];
+        }
+      }
+    }
+  }
+  return mappingsByVocabularyValue;
+};
+const filterMappingsByVocabularyValue = getFilterMappingsByVocabularyValue();
+const getIsValueInFilterVocabulary = (category, value) => !!filterMappingsByVocabularyValue[getNormalizedFilterValue(value)]?.some(
+  (mapping) => mapping.category === category
+);
+const getFilterMappingsHoldingValues = (category, values) => {
+  let mappingsHoldingValues = [];
+  let isFirstValue = true;
+  for (const value of values) {
+    const mappingsHoldingValue = (filterMappingsByVocabularyValue[getNormalizedFilterValue(value)] || []).filter((mapping) => mapping.category !== category);
+    mappingsHoldingValues = isFirstValue ? mappingsHoldingValue : mappingsHoldingValues.filter(
+      (mapping) => mappingsHoldingValue.includes(mapping)
+    );
+    isFirstValue = false;
+  }
+  return mappingsHoldingValues;
+};
+const getSuggestedFilterKey = (category, values) => {
+  const mappingsHoldingValues = getFilterMappingsHoldingValues(
+    category,
+    values
+  );
+  const [suggestedMapping] = mappingsHoldingValues;
+  return mappingsHoldingValues.length === 1 ? suggestedMapping.canonicalAlias : void 0;
+};
 export {
   FilterCategory,
   FilterKind,
@@ -446,5 +499,8 @@ export {
   availableModifiers,
   filtersToCardPropertyMappings,
   filtersToCardPropertyMappingsByKey,
-  getFilterCategory
+  getFilterCategory,
+  getFilterMapping,
+  getIsValueInFilterVocabulary,
+  getSuggestedFilterKey
 };

package/dist/filterResolvers.d.ts

@@ -0,0 +1,49 @@
+import { Foiling, Hero, Rarity, Release, Treatment } from "@flesh-and-blood/types";
+import { FilterCategory, type AppliedFilter, type FilterToPropertyMapping, type FilterValue } from "./filterMappings.js";
+import { CatalogueIndex } from "./searchIndex.js";
+/**
+ * What a query says about the printings each result renders, and about their
+ * order. They narrow no further which cards answer.
+ */
+export interface QueryAttributes {
+    artists: string[];
+    foilings: Foiling[];
+    isExpansionSlot: boolean;
+    prints: string[];
+    rarities: Rarity[];
+    releases: Release[];
+    treatments: Treatment[];
+}
+/** A filter term to resolve: the filter it names, and what it asks of it. */
+export interface FilterTerm {
+    category: FilterCategory;
+    filterValues: FilterValue[];
+    isAnd: boolean;
+    isExcluded: boolean;
+    key: string;
+    mapping: FilterToPropertyMapping;
+}
+/** What a resolver reads besides the term itself. */
+export interface FilterResolverContext {
+    additionalHeroes: Hero[];
+    additionalSets: Release[];
+    index: CatalogueIndex;
+    today: string;
+}
+export interface FilterResolution {
+    appliedFilters: AppliedFilter[];
+    attributes?: Partial<QueryAttributes>;
+    /**
+     * The values the filter reads in place of the ones written, where a resolver
+     * read them as others: `foil:cf` as cold, `p:red` as a pitch of 1. Absent
+     * where the filter matches on the values as they were written.
+     */
+    canonicalValues?: string[];
+    /** The values naming nothing the filter reads, as they were written. */
+    unresolvedValues: string[];
+}
+export declare const RARITY_VALUES_MAPPING: {
+    [key: string]: Rarity;
+};
+/** What one filter term asks for, whichever filter it names. */
+export declare const getFilterResolution: (term: FilterTerm, context: FilterResolverContext) => FilterResolution;