@sigil-sifter/magic 1.0.0

package/src/expressions/is/SplitExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class SplitExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^split/i);
+    }
+
+    includes(card) {
+        return card.isSplit;
+    }
+}

package/src/expressions/is/SpotlightExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class SpotlightExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^spotlight/i);
+    }
+
+    includes(card) {
+        return card.isSpotlight;
+    }
+}

package/src/expressions/is/TextlessExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class TextlessExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^textless/i);
+    }
+
+    includes(card) {
+        return card.isTextless;
+    }
+}

package/src/expressions/is/TransformExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class TransformExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^transform/i);
+    }
+
+    includes(card) {
+        return card.isTransform;
+    }
+}

package/src/expressions/is/UniversesBeyondExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class UniversesBeyondExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^(ub|universesbeyond)/i);
+    }
+
+    includes(card) {
+        return card.isUniversesBeyond;
+    }
+}

package/src/expressions/is/VanillaExpression.js

@@ -0,0 +1,11 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class VanillaExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(/^vanilla/i);
+    }
+
+    includes(card) {
+        return card.isVanilla;
+    }
+}

package/src/expressions/is/index.js

@@ -0,0 +1,59 @@
+import BoosterExpression from './BoosterExpression.js';
+import DFCExpression from './DFCExpression.js';
+import EtchedExpression from './EtchedExpression.js';
+import FlipExpression from './FlipExpression.js';
+import FoilExpression from './FoilExpression.js';
+import FullArtExpression from './FullArtExpression.js';
+import FrenchVanillaExpression from './FrenchVanillaExpression.js';
+import GlossyExpression from './GlossyExpression.js';
+import HistoricExpression from './HistoricExpression.js';
+import HybridExpression from './HybridExpression.js';
+import LevelerExpression from './LevelerExpression.js';
+import MDFCExpression from './MDFCExpression.js';
+import MeldExpression from './MeldExpression.js';
+import ModalExpression from './ModalExpression.js';
+import NonFoilExpression from './NonFoilExpression.js';
+import PartyExpression from './PartyExpression.js';
+import PermanentExpression from './PermanentExpression.js';
+import PhyrexianExpression from './PhyrexianExpression.js';
+import PromoExpression from './PromoExpression.js';
+import ReprintExpression from './ReprintExpression.js';
+import ReservedExpression from './ReservedExpression.js';
+import SpellExpression from './SpellExpression.js';
+import SplitExpression from './SplitExpression.js';
+import SpotlightExpression from './SpotlightExpression.js';
+import TextlessExpression from './TextlessExpression.js';
+import TransformExpression from './TransformExpression.js';
+import UniversesBeyondExpression from './UniversesBeyondExpression.js';
+import VanillaExpression from './VanillaExpression.js';
+
+export {
+    BoosterExpression,
+    DFCExpression,
+    EtchedExpression,
+    FlipExpression,
+    FoilExpression,
+    FrenchVanillaExpression,
+    FullArtExpression,
+    GlossyExpression,
+    HistoricExpression,
+    HybridExpression,
+    LevelerExpression,
+    MDFCExpression,
+    MeldExpression,
+    ModalExpression,
+    NonFoilExpression,
+    PartyExpression,
+    PermanentExpression,
+    PhyrexianExpression,
+    PromoExpression,
+    ReprintExpression,
+    ReservedExpression,
+    SpellExpression,
+    SplitExpression,
+    SpotlightExpression,
+    TextlessExpression,
+    TransformExpression,
+    UniversesBeyondExpression,
+    VanillaExpression,
+}

package/src/extensions/ColorExtension.js

@@ -0,0 +1,22 @@
+import defaultColors from '../data/colors.js';
+import defaultGuilds from '../data/guilds.js';
+
+export default class ColorExtension {
+    constructor(data) {
+        this.colors = data.colors || defaultColors;
+        this.guilds = data.guilds || defaultGuilds;
+    }
+
+    resolveColors(str) {
+        const allOptions = this.colors.concat(this.guilds);
+        const colorByName = allOptions.find(c => c.expr.test(str));
+        return colorByName
+            ? colorByName.colorChars
+            : [...new Set(str.toUpperCase().split(''))];
+    }
+
+    get colorNamesExpr() {
+        const colorNames = this.colors.concat(this.guilds).map(c => c.name);
+        return new RegExp(`^(${colorNames.join('|')})`, 'i');
+    }
+}

package/src/extensions/FormatExtension.js

@@ -0,0 +1,15 @@
+import defaultGameFormats from '../data/gameFormats.js';
+
+export default class FormatExtension {
+    constructor(data) {
+        this.gameFormats = data.gameFormats || defaultGameFormats;
+        this.gameFormats.forEach(format => {
+            if (format.expr) return;
+            format.expr = new RegExp(`^${format.name}$`, 'i')
+        });
+    }
+
+    resolveFormat(value) {
+        return this.gameFormats.find(g => g.expr.test(value));
+    }
+}

package/src/extensions/GameExtension.js

@@ -0,0 +1,15 @@
+import defaultGames from '../data/games.js';
+
+export default class GameExtension {
+    constructor(data) {
+        this.games = data.games || defaultGames;
+        this.games.forEach(g => {
+            if (g.expr) return;
+            g.expr = new RegExp(`^${g.name}$`, 'i')
+        });
+    }
+
+    resolveGame(value) {
+        return this.games.find(g => g.expr.test(value));
+    }
+}

package/src/extensions/KeywordExtension.js

@@ -0,0 +1,11 @@
+import defaultAbilityWords from '../data/abilityWords.js';
+
+export default class KeywordExtension {
+    constructor(data) {
+        this.abilityWords = data.abilityWords || defaultAbilityWords;
+    }
+
+    isAbilityWord(str) {
+        return this.abilityWords.includes(str);
+    }
+}

package/src/extensions/LanguageExtension.js

@@ -0,0 +1,15 @@
+import defaultLanguages from '../data/languages.js';
+
+export default class LanguageExtension {
+    constructor(data) {
+        this.languages = data.languages || defaultLanguages;
+    }
+
+    resolveLanguage(str) {
+        const lcStr = str.toLowerCase();
+        return this.languages.find(lang => {
+            return lang.acronyms.includes(lcStr)
+                || lang.expr.test(str);
+        });
+    }
+}

package/src/extensions/RarityExtension.js

@@ -0,0 +1,20 @@
+import defaultRarities from '../data/rarities.js';
+
+export default class RarityExtension {
+    constructor(data) {
+        this.rarities = data.rarities || defaultRarities;
+        this.rarities.forEach(r => {
+            if (r.expr) return;
+            r.expr = new RegExp(`^(${r.char}|${r.name})$`, 'i')
+        });
+    }
+
+    resolveRarity(value) {
+        return this.rarities.find(r => r.expr.test(value));
+    }
+
+    get rarityExpr() {
+        const namesAndChars = this.rarities.flatMap(r => [r.char, r.name]);
+        return new RegExp(`^(${namesAndChars.join('|')})$`, 'i');
+    }
+}

package/src/extensions/SetExtension.js

@@ -0,0 +1,13 @@
+export default class SetExtension {
+    constructor(data) {
+        this.sets = data.sets || [];
+        this.sets.forEach(set => {
+            if (set.expr) return;
+            set.expr = new RegExp(`^(${set.name}|${set.code})$`, 'i');
+        });
+    }
+
+    resolveSet(str) {
+        return this.sets.find(set => set.expr.test(str));
+    }
+}

package/src/index.js

@@ -0,0 +1,36 @@
+import MagicCard from './core/MagicCard.js';
+import ColorExtension from './extensions/ColorExtension.js';
+import FormatExtension from './extensions/FormatExtension.js';
+import GameExtension from './extensions/GameExtension.js';
+import KeywordExtension from './extensions/KeywordExtension.js';
+import LanguageExtension from './extensions/LanguageExtension.js';
+import RarityExtension from './extensions/RarityExtension.js';
+import SetExtension from './extensions/SetExtension.js';
+import * as keywords from './keywords/index.js';
+
+export default function register(sifter, Card, data = {}) {
+    if (!Card)
+        throw new Error('A valid Card class must be provided.');
+    if (!(Card.prototype instanceof MagicCard))
+        throw new Error('Card class must inherit from MagicCard');
+
+    sifter.addKeywords(Object.values(keywords));
+
+    sifter.setBaseStringParser((sifter, operator, expression) => {
+        const keyword = new keywords.NameKeyword(sifter);
+        keyword.operator = operator;
+        keyword.expression = expression;
+        keyword.remainingStr = expression.remainingStr;
+        return keyword;
+    });
+
+    sifter.setInputAdapter(Card);
+
+    sifter.extend(ColorExtension, data);
+    sifter.extend(FormatExtension, data);
+    sifter.extend(GameExtension, data);
+    sifter.extend(KeywordExtension, data);
+    sifter.extend(LanguageExtension, data);
+    sifter.extend(SetExtension, data);
+    sifter.extend(RarityExtension, data);
+};

package/src/keywords/AbilityKeyword.js

@@ -0,0 +1,16 @@
+import { Keyword } from 'sigil-sifter/keywords';
+import KeywordAbilityExpression from '../expressions/KeywordAbilityExpression.js';
+
+export default class AbilityKeyword extends Keyword {
+    static get keys() {
+        return ['keyword', 'kw'];
+    }
+
+    static get supportedExpressions() {
+        return [KeywordAbilityExpression];
+    }
+
+    test(card) {
+        return this.operator.testValue(card.keywords, this.expression);
+    }
+}

package/src/keywords/ArtistKeyword.js

@@ -0,0 +1,11 @@
+import { StringKeyword } from 'sigil-sifter/keywords';
+
+export default class ArtistKeyword extends StringKeyword {
+    static get keys() {
+        return ['artist', 'a'];
+    }
+
+    test(card) {
+        return card.artists.some(a => super.test(a));
+    }
+}

package/src/keywords/BannedKeyword.js

@@ -0,0 +1,21 @@
+import { Keyword } from 'sigil-sifter/keywords';
+import FormatExpression from '../expressions/FormatExpression.js';
+import { EqualsOperator, IncludesOperator } from 'sigil-sifter/operators';
+
+export default class BannedKeyword extends Keyword {
+    static get keys() {
+        return ['banned'];
+    }
+
+    static get supportedOperators() {
+        return [IncludesOperator, EqualsOperator];
+    }
+
+    static get supportedExpressions() {
+        return [FormatExpression];
+    }
+
+    test(card) {
+        return card.banned.some(formatName => super.test(formatName));
+    }
+}

package/src/keywords/BorderKeyword.js

@@ -0,0 +1,21 @@
+import { Keyword } from 'sigil-sifter/keywords';
+import ExactStringExpression from '../expressions/ExactStringExpression.js';
+import { EqualsOperator, IncludesOperator } from 'sigil-sifter/operators';
+
+export default class BorderKeyword extends Keyword {
+    static get keys() {
+        return ['border'];
+    }
+
+    static get supportedOperators() {
+        return [IncludesOperator, EqualsOperator];
+    }
+
+    static get supportedExpressions() {
+        return [ExactStringExpression];
+    }
+
+    test(card) {
+        return super.test(card.border);
+    }
+}

package/src/keywords/CardTypeKeyword.js

@@ -0,0 +1,11 @@
+import { StringKeyword } from 'sigil-sifter/keywords';
+
+export default class CardTypeKeyword extends StringKeyword {
+    static get keys() {
+        return ['type', 't'];
+    }
+
+    test(card) {
+        return card.typeLines.some(t => super.test(t));
+    }
+}

package/src/keywords/CollectorNumberKeyword.js

@@ -0,0 +1,16 @@
+import { NumericExpression } from 'sigil-sifter/expressions';
+import { Keyword } from 'sigil-sifter/keywords';
+
+export default class CollectorNumberKeyword extends Keyword {
+    static get keys() {
+        return ['number', 'cn'];
+    }
+
+    static get supportedExpressions() {
+        return [NumericExpression];
+    }
+
+    test(card) {
+        return super.test(card.collectorNumber);
+    }
+}

package/src/keywords/ColorIdentityKeyword.js

@@ -0,0 +1,11 @@
+import ColorKeyword from './ColorKeyword.js';
+
+export default class ColorIdentityKeyword extends ColorKeyword {
+    static get keys() {
+        return ['identity', 'id'];
+    }
+
+    test(card) {
+        return this.operator.testValue(card.colorIdentity, this.expression);
+    }
+}

package/src/keywords/ColorKeyword.js

@@ -0,0 +1,17 @@
+import { Keyword } from 'sigil-sifter/keywords';
+import ColorExpression from '../expressions/ColorExpression.js';
+import ArrayLengthExpression from '../expressions/ArrayLengthExpression.js';
+
+export default class ColorKeyword extends Keyword {
+    static get keys() {
+        return ['colors', 'color', 'c'];
+    }
+
+    static get supportedExpressions() {
+        return [ColorExpression, ArrayLengthExpression];
+    }
+
+    test(card) {
+        return this.operator.testValue(card.colors, this.expression);
+    }
+}

package/src/keywords/DevotionKeyword.js

@@ -0,0 +1,21 @@
+import { Keyword } from 'sigil-sifter/keywords';
+import { ManaCost } from 'mana-scribe';
+import DevotionExpression from '../expressions/DevotionExpression.js';
+
+export default class DevotionKeyword extends Keyword {
+    static get keys() {
+        return  ['devotion'];
+    }
+
+    static get supportedExpressions() {
+        return [DevotionExpression];
+    }
+
+    test(card) {
+        if (!card.isPermanent) return false;
+        const manaCosts = card.cache('manaCosts', () => {
+            return card.manaCosts.map(costStr => ManaCost.parse(costStr));
+        });
+        return manaCosts.some(manaCost => super.test(manaCost));
+    }
+}

package/src/keywords/FlavorTextKeyword.js

@@ -0,0 +1,11 @@
+import { StringKeyword } from 'sigil-sifter/keywords';
+
+export default class FlavorTextKeyword extends StringKeyword {
+    static get keys() {
+        return ['flavor', 'ft'];
+    }
+
+    test(card) {
+        return card.flavorTexts.some(flavorText => super.test(flavorText));
+    }
+}

package/src/keywords/FormatKeyword.js

@@ -0,0 +1,21 @@
+import { Keyword } from 'sigil-sifter/keywords';
+import FormatExpression from '../expressions/FormatExpression.js';
+import { EqualsOperator, IncludesOperator } from 'sigil-sifter/operators';
+
+export default class FormatKeyword extends Keyword {
+    static get keys() {
+        return ['format', 'f'];
+    }
+
+    static get supportedOperators() {
+        return [IncludesOperator, EqualsOperator];
+    }
+
+    static get supportedExpressions() {
+        return [FormatExpression];
+    }
+
+    test(card) {
+        return card.formats.some(formatName => super.test(formatName));
+    }
+}

package/src/keywords/FrameKeyword.js

@@ -0,0 +1,22 @@
+import { Keyword } from 'sigil-sifter/keywords';
+import ExactStringExpression from '../expressions/ExactStringExpression.js';
+import { EqualsOperator, IncludesOperator } from 'sigil-sifter/operators';
+
+export default class FrameKeyword extends Keyword {
+    static get keys() {
+        return ['frame'];
+    }
+
+    static get supportedOperators() {
+        return [IncludesOperator, EqualsOperator];
+    }
+
+    static get supportedExpressions() {
+        return [ExactStringExpression];
+    }
+
+    test(card) {
+        return super.test(card.frame)
+            || card.frameEffects.some(fe => super.test(fe));
+    }
+}

package/src/keywords/GameKeyword.js

@@ -0,0 +1,21 @@
+import { Keyword } from 'sigil-sifter/keywords';
+import GameExpression from '../expressions/GameExpression.js';
+import { EqualsOperator, IncludesOperator } from 'sigil-sifter/operators';
+
+export default class GameKeyword extends Keyword {
+    static get keys() {
+        return ['game'];
+    }
+
+    static get supportedOperators() {
+        return [IncludesOperator, EqualsOperator];
+    }
+
+    static get supportedExpressions() {
+        return [GameExpression];
+    }
+
+    test(card) {
+        return super.test(card.games);
+    }
+}

package/src/keywords/HasKeyword.js

@@ -0,0 +1,13 @@
+import { Keyword } from 'sigil-sifter/keywords';
+import IndicatorExpression from '../expressions/has/IndicatorExpression.js';
+import WatermarkExpression from '../expressions/has/WatermarkExpression.js';
+
+export default class HasKeyword extends Keyword {
+    static get keys() {
+        return ['has'];
+    }
+
+    static get supportedExpressions() {
+        return [IndicatorExpression, WatermarkExpression];
+    }
+}

package/src/keywords/IsKeyword.js

@@ -0,0 +1,17 @@
+import { Keyword } from 'sigil-sifter/keywords';
+import { IncludesOperator } from 'sigil-sifter/operators';
+import * as booleanExpressions from '../expressions/is/index.js';
+
+export default class IsKeyword extends Keyword {
+    static get keys() {
+        return ['is'];
+    }
+
+    static get supportedOperators() {
+        return [IncludesOperator];
+    }
+
+    static get supportedExpressions() {
+        return Object.values(booleanExpressions);
+    }
+}

package/src/keywords/LanguageKeyword.js

@@ -0,0 +1,16 @@
+import { Keyword } from 'sigil-sifter/keywords';
+import LanguageExpression from '../expressions/LanguageExpression.js';
+
+export default class LanguageKeyword extends Keyword {
+    static get keys() {
+        return ['language', 'lang'];
+    }
+
+    static get supportedExpressions() {
+        return [LanguageExpression];
+    }
+
+    test(card) {
+        return super.test(card.language);
+    }
+}

package/src/keywords/LoyaltyKeyword.js

@@ -0,0 +1,16 @@
+import { Keyword } from 'sigil-sifter/keywords';
+import { NumericExpression } from 'sigil-sifter/expressions';
+
+export default class LoyaltyKeyword extends Keyword {
+    static get keys() {
+        return ['loyalty', 'loy'];
+    }
+
+    static get supportedExpressions() {
+        return [NumericExpression];
+    }
+
+    test(card) {
+        return super.test(card.loyalty);
+    }
+}

package/src/keywords/ManaCostKeyword.js

@@ -0,0 +1,20 @@
+import { Keyword } from 'sigil-sifter/keywords';
+import { ManaCost } from 'mana-scribe';
+import ManaExpression from '../expressions/ManaExpression.js';
+
+export default class ManaCostKeyword extends Keyword {
+    static get keys() {
+        return  ['mana', 'm'];
+    }
+
+    static get supportedExpressions() {
+        return [ManaExpression];
+    }
+
+    test(card) {
+        const manaCosts = card.cache('manaCosts', () => {
+            return card.manaCosts.map(costStr => ManaCost.parse(costStr));
+        });
+        return manaCosts.some(manaCost => super.test(manaCost));
+    }
+}

package/src/keywords/ManaValueKeyword.js

@@ -0,0 +1,17 @@
+import { Keyword } from 'sigil-sifter/keywords';
+import { NumericExpression } from 'sigil-sifter/expressions';
+import EvenOddExpression from '../expressions/EvenOddExpression.js';
+
+export default class ManaValueKeyword extends Keyword {
+    static get keys() {
+        return  ['manavalue', 'mv', 'cmc'];
+    }
+
+    static get supportedExpressions() {
+        return [NumericExpression, EvenOddExpression];
+    }
+
+    test(card) {
+        return card.manaValues.some(mv => super.test(mv));
+    }
+}

package/src/keywords/NameKeyword.js

@@ -0,0 +1,11 @@
+import { StringKeyword } from 'sigil-sifter/keywords';
+
+export default class NameKeyword extends StringKeyword {
+    static get keys() {
+        return ['name'];
+    }
+
+    test(card) {
+        return card.names.some(name => super.test(name));
+    }
+}