@flesh-and-blood/search 5.0.14 → 5.0.16

package/dist/filterMappings.d.ts

@@ -0,0 +1,836 @@
+import { Bond, Card, Class, Flow, Foiling, Fusion, Hero, Keyword, Meta, Printing, Rarity, Release, Shorthand, Subtype, Talent, Trait, Treatment, Type } from "@flesh-and-blood/types";
+/**
+ * Which filter a key names, rather than how it was spelled: every alias of a
+ * filter answers with the one category, and a key naming no filter answers
+ * with nothing. The advanced search dialog offers a subset of these under the
+ * same strings, so a category is also what an app and the engine agree a query
+ * token means.
+ */
+export declare const FilterCategory: {
+    readonly Arcane: "arcane";
+    readonly Artist: "artist";
+    readonly Banned: "banned";
+    readonly Bond: "bond";
+    readonly Chain: "chain";
+    readonly Class: "class";
+    readonly Cost: "cost";
+    readonly Defense: "defense";
+    readonly Flow: "flow";
+    readonly Foiling: "foiling";
+    readonly Fusion: "fusion";
+    readonly Intellect: "intellect";
+    readonly Is: "is";
+    readonly Keyword: "keyword";
+    readonly Legal: "legal";
+    readonly Life: "life";
+    readonly Name: "name";
+    readonly Pitch: "pitch";
+    readonly Power: "power";
+    readonly Print: "print";
+    readonly Rarity: "rarity";
+    readonly ReferencedBy: "referencedby";
+    readonly References: "references";
+    readonly Set: "set";
+    readonly Shorthand: "shorthand";
+    readonly Specialization: "specialization";
+    readonly Subtype: "subtype";
+    readonly Talent: "talent";
+    readonly Text: "text";
+    readonly Trait: "trait";
+    readonly Treatment: "treatment";
+    readonly Type: "type";
+    readonly TypeText: "typetext";
+    readonly Year: "year";
+};
+export type FilterCategory = (typeof FilterCategory)[keyof typeof FilterCategory];
+/** How a filter reads the value written against it in a query. */
+export declare const FilterKind: {
+    /** A number, which the query may put a comparison in front of. */
+    readonly Comparator: "comparator";
+    /** A whole value, so a fragment of one names nothing. */
+    readonly ExactMatch: "exactMatch";
+    /** A fragment, which stands for anything it sits inside. */
+    readonly PartialMatch: "partialMatch";
+};
+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. */
+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 parse resolved.
+ */
+export declare const NO_CARD_PROPERTY = "n/a";
+/**
+ * The field holding the value a card prints where a number would be, which a
+ * numeric filter falls back to for a card carrying no number.
+ */
+export type CardSpecialPropertyName = "specialArcane" | "specialCost" | "specialDefense" | "specialLife" | "specialPower";
+/**
+ * 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.
+ */
+export interface CardPropertyMapping {
+    nestedProperty?: keyof Printing;
+    property: CardPropertyName | typeof NO_CARD_PROPERTY;
+    exclusion?: Exclusion;
+    isArray?: boolean;
+    isNestedPropertyArray?: boolean;
+    isNumber?: boolean;
+    isString?: boolean;
+    isBoolean?: boolean;
+    isDate?: boolean;
+    /**
+     * The card stores this property with markdown emphasis around its keywords,
+     * so the matcher strips that from both sides. A searched phrase then reads
+     * the text the way the card renders it rather than the way it is stored,
+     * and a phrase spanning a keyword boundary still matches.
+     */
+    hasMarkup?: boolean;
+    isMeta?: boolean;
+    /**
+     * The card stores this property the way a filter value is written, so the
+     * matcher compares it as stored instead of stripping punctuation and case
+     * from it first.
+     */
+    isNormalized?: boolean;
+    modifier?: Modifier;
+    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
+ * values a card can carry.
+ */
+export interface FilterToPropertyMapping extends CardPropertyMapping {
+    category: FilterCategory;
+    /**
+     * The one spelling that names this filter where a query is composed rather
+     * than parsed: a hint, the syntax help, and the text the advanced search
+     * dialog writes. Every alias parses, so the choice decides only what gets
+     * written, and a reader's saved query carries it. A filter the dialog offers
+     * keeps the spelling that dialog already emits; any other filter takes the
+     * shortest spelling the syntax help teaches, and its own word where the help
+     * teaches none.
+     */
+    canonicalAlias: string;
+    kind: FilterKind;
+    /**
+     * 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 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`),
+     * a set identifier (`print`), a date (`year`) or a number carries none.
+     */
+    vocabulary?: readonly string[];
+}
+/** Every spelling a query can write, against the filter it names. */
+export declare const filtersToCardPropertyMappings: {
+    arcane: {
+        category: "arcane";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "arcane";
+        specialProperty: "specialArcane";
+        isNumber: true;
+        partialMatch: true;
+    };
+    a: {
+        category: "artist";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "artists";
+        isArray: true;
+        partialMatch: true;
+    };
+    artist: {
+        category: "artist";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "artists";
+        isArray: true;
+        partialMatch: true;
+    };
+    art: {
+        category: "artist";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "artists";
+        isArray: true;
+        partialMatch: true;
+    };
+    attack: {
+        category: "power";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "power";
+        specialProperty: "specialPower";
+        isNumber: true;
+    };
+    b: {
+        category: "defense";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "defense";
+        specialProperty: "specialDefense";
+        isNumber: true;
+    };
+    block: {
+        category: "defense";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "defense";
+        specialProperty: "specialDefense";
+        isNumber: true;
+    };
+    banned: {
+        category: "banned";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: readonly string[];
+        property: "n/a";
+        isMeta: true;
+    };
+    bond: {
+        category: "bond";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Bond.Earth[];
+        property: "bonds";
+        isArray: true;
+    };
+    bonds: {
+        category: "bond";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Bond.Earth[];
+        property: "bonds";
+        isArray: true;
+    };
+    c: {
+        category: "class";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        vocabulary: Class[];
+        property: "classes";
+        isArray: true;
+        partialMatch: true;
+    };
+    class: {
+        category: "class";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        vocabulary: Class[];
+        property: "classes";
+        isArray: true;
+        partialMatch: true;
+    };
+    chain: {
+        category: "chain";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "n/a";
+    };
+    co: {
+        category: "cost";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "cost";
+        specialProperty: "specialCost";
+        isNumber: true;
+        partialMatch: true;
+    };
+    cost: {
+        category: "cost";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "cost";
+        specialProperty: "specialCost";
+        isNumber: true;
+        partialMatch: true;
+    };
+    color: {
+        category: "pitch";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "pitch";
+        isNumber: true;
+    };
+    d: {
+        category: "defense";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "defense";
+        specialProperty: "specialDefense";
+        isNumber: true;
+    };
+    def: {
+        category: "defense";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "defense";
+        specialProperty: "specialDefense";
+        isNumber: true;
+    };
+    defense: {
+        category: "defense";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "defense";
+        specialProperty: "specialDefense";
+        isNumber: true;
+    };
+    flow: {
+        category: "flow";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Flow.Lightning[];
+        property: "flows";
+        isArray: true;
+    };
+    flows: {
+        category: "flow";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Flow.Lightning[];
+        property: "flows";
+        isArray: true;
+    };
+    f: {
+        category: "fusion";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Fusion[];
+        property: "fusions";
+        isArray: true;
+    };
+    fusion: {
+        category: "fusion";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Fusion[];
+        property: "fusions";
+        isArray: true;
+    };
+    foil: {
+        category: "foiling";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Foiling[];
+        nestedProperty: "foiling";
+        property: "printings";
+        isArray: true;
+    };
+    foiling: {
+        category: "foiling";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Foiling[];
+        nestedProperty: "foiling";
+        property: "printings";
+        isArray: true;
+    };
+    i: {
+        category: "intellect";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "intellect";
+        isNumber: true;
+    };
+    intellect: {
+        category: "intellect";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "intellect";
+        isNumber: true;
+    };
+    is: {
+        category: "is";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Meta[];
+        property: "meta";
+        isArray: true;
+    };
+    k: {
+        category: "keyword";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Keyword[];
+        property: "keywords";
+        isArray: true;
+    };
+    keyword: {
+        category: "keyword";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Keyword[];
+        property: "keywords";
+        isArray: true;
+    };
+    l: {
+        category: "legal";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: readonly string[];
+        property: "n/a";
+        isMeta: true;
+    };
+    legal: {
+        category: "legal";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: readonly string[];
+        property: "n/a";
+        isMeta: true;
+    };
+    hero: {
+        category: "legal";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: readonly string[];
+        property: "n/a";
+        isMeta: true;
+    };
+    li: {
+        category: "life";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "life";
+        specialProperty: "specialLife";
+        isNumber: true;
+    };
+    life: {
+        category: "life";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "life";
+        specialProperty: "specialLife";
+        isNumber: true;
+    };
+    meta: {
+        category: "is";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Meta[];
+        property: "meta";
+        isArray: true;
+    };
+    n: {
+        category: "name";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "name";
+        isString: true;
+        partialMatch: true;
+    };
+    name: {
+        category: "name";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "name";
+        isString: true;
+        partialMatch: true;
+    };
+    p: {
+        category: "pitch";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "pitch";
+        isNumber: true;
+    };
+    pitch: {
+        category: "pitch";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "pitch";
+        isNumber: true;
+    };
+    pwr: {
+        category: "power";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "power";
+        specialProperty: "specialPower";
+        isNumber: true;
+    };
+    pow: {
+        category: "power";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "power";
+        specialProperty: "specialPower";
+        isNumber: true;
+    };
+    power: {
+        category: "power";
+        canonicalAlias: string;
+        kind: "comparator";
+        property: "power";
+        specialProperty: "specialPower";
+        isNumber: true;
+    };
+    print: {
+        category: "print";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "setIdentifiers";
+        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;
+        kind: "exactMatch";
+        vocabulary: Rarity[];
+        property: "n/a";
+        isMeta: true;
+    };
+    rarity: {
+        category: "rarity";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Rarity[];
+        property: "n/a";
+        isMeta: true;
+    };
+    referencedby: {
+        category: "referencedby";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "n/a";
+    };
+    references: {
+        category: "references";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "n/a";
+    };
+    rf: {
+        category: "banned";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: readonly string[];
+        property: "n/a";
+        isMeta: true;
+    };
+    s: {
+        category: "set";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        vocabulary: Release[];
+        property: "sets";
+        isArray: true;
+        partialMatch: true;
+    };
+    set: {
+        category: "set";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        vocabulary: Release[];
+        property: "sets";
+        isArray: true;
+        partialMatch: true;
+    };
+    short: {
+        category: "shorthand";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        vocabulary: Shorthand[];
+        property: "shorthands";
+        isArray: true;
+        partialMatch: true;
+    };
+    shorthand: {
+        category: "shorthand";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        vocabulary: Shorthand[];
+        property: "shorthands";
+        isArray: true;
+        partialMatch: true;
+    };
+    shorthands: {
+        category: "shorthand";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        vocabulary: Shorthand[];
+        property: "shorthands";
+        isArray: true;
+        partialMatch: true;
+    };
+    sp: {
+        category: "specialization";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        vocabulary: Hero[];
+        property: "specializations";
+        isArray: true;
+        partialMatch: true;
+    };
+    spec: {
+        category: "specialization";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        vocabulary: Hero[];
+        property: "specializations";
+        isArray: true;
+        partialMatch: true;
+    };
+    specialization: {
+        category: "specialization";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        vocabulary: Hero[];
+        property: "specializations";
+        isArray: true;
+        partialMatch: true;
+    };
+    specializations: {
+        category: "specialization";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        vocabulary: Hero[];
+        property: "specializations";
+        isArray: true;
+        partialMatch: true;
+    };
+    st: {
+        category: "subtype";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Subtype[];
+        property: "subtypes";
+        isArray: true;
+    };
+    subtype: {
+        category: "subtype";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Subtype[];
+        property: "subtypes";
+        isArray: true;
+    };
+    t: {
+        category: "type";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Type[];
+        property: "types";
+        isArray: true;
+    };
+    type: {
+        category: "type";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Type[];
+        property: "types";
+        isArray: true;
+    };
+    tal: {
+        category: "talent";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Talent[];
+        property: "talents";
+        isArray: true;
+    };
+    talent: {
+        category: "talent";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Talent[];
+        property: "talents";
+        isArray: true;
+    };
+    talents: {
+        category: "talent";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Talent[];
+        property: "talents";
+        isArray: true;
+    };
+    text: {
+        category: "text";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "functionalText";
+        hasMarkup: true;
+        isString: true;
+        partialMatch: true;
+    };
+    trait: {
+        category: "trait";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        vocabulary: Trait.AgentOfChaos[];
+        property: "traits";
+        isArray: true;
+        partialMatch: true;
+    };
+    treat: {
+        category: "treatment";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Treatment[];
+        nestedProperty: "treatments";
+        property: "printings";
+        isArray: true;
+        isNestedPropertyArray: true;
+    };
+    treatment: {
+        category: "treatment";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Treatment[];
+        nestedProperty: "treatments";
+        property: "printings";
+        isArray: true;
+        isNestedPropertyArray: true;
+    };
+    var: {
+        category: "treatment";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Treatment[];
+        nestedProperty: "treatments";
+        property: "printings";
+        isArray: true;
+        isNestedPropertyArray: true;
+    };
+    variation: {
+        category: "treatment";
+        canonicalAlias: string;
+        kind: "exactMatch";
+        vocabulary: Treatment[];
+        nestedProperty: "treatments";
+        property: "printings";
+        isArray: true;
+        isNestedPropertyArray: true;
+    };
+    x: {
+        category: "typetext";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "typeText";
+        isString: true;
+        partialMatch: true;
+    };
+    typetext: {
+        category: "typetext";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "typeText";
+        isString: true;
+        partialMatch: true;
+    };
+    year: {
+        category: "year";
+        canonicalAlias: string;
+        kind: "partialMatch";
+        property: "firstReleaseDate";
+        isString: true;
+        partialMatch: true;
+    };
+};
+/**
+ * The same mappings, read by a key a query wrote. Filter keys are typed by the
+ * searcher, so an unrecognised key is a miss to skip rather than a type error.
+ */
+export declare const filtersToCardPropertyMappingsByKey: {
+    [key: string]: FilterToPropertyMapping | undefined;
+};
+/**
+ * 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;