@sigil-sifter/magic 1.0.0

package/src/keywords/NotKeyword.js

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

package/src/keywords/PowerKeyword.js

@@ -0,0 +1,29 @@
+import { SearchSyntaxError } from 'sigil-sifter/core';
+import { NumericExpression } from 'sigil-sifter/expressions';
+import { Keyword } from 'sigil-sifter/keywords';
+import PowTouExpression from '../expressions/PowTouExpression.js';
+import { comparingPtAgainst } from '../core/helpers.js';
+
+export default class PowerKeyword extends Keyword {
+    static get keys() {
+        return ['power', 'pow'];
+    }
+
+    static get supportedExpressions() {
+        return [NumericExpression, PowTouExpression];
+    }
+
+    static parse(sifter, match, str) {
+        const keyword = super.parse(sifter, match, str);
+        if (comparingPtAgainst(keyword.expression, 'power'))
+            throw new SearchSyntaxError('Cannot compare power against itself.');
+        return keyword;
+    }
+
+    test(card) {
+        if (this.expression.constructor === PowTouExpression)
+            return card.pts.some(pt => super.test(pt));
+
+        return card.pts.some(pt => super.test(pt.power));
+    }
+}

package/src/keywords/ProducesKeyword.js

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

package/src/keywords/RarityKeyword.js

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

package/src/keywords/RestrictedKeyword.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 RestrictedKeyword extends Keyword {
+    static get keys() {
+        return ['restricted'];
+    }
+
+    static get supportedOperators() {
+        return [IncludesOperator, EqualsOperator];
+    }
+
+    static get supportedExpressions() {
+        return [FormatExpression];
+    }
+
+    test(card) {
+        return card.restricted.some(formatName => super.test(formatName));
+    }
+}

package/src/keywords/RulesTextKeyword.js

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

package/src/keywords/SetKeyword.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 SetKeyword extends Keyword {
+    static get keys() {
+        return ['set', 'edition', 's', 'e'];
+    }
+
+    static get supportedOperators() {
+        return [IncludesOperator, EqualsOperator];
+    }
+
+    static get supportedExpressions() {
+        return [ExactStringExpression];
+    }
+
+    test(card) {
+        return super.test(card.set.code) || super.test(card.set.name);
+    }
+}

package/src/keywords/SetTypeKeyword.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 SetTypeKeyword extends Keyword {
+    static get keys() {
+        return ['settype', 'st'];
+    }
+
+    static get supportedOperators() {
+        return [IncludesOperator, EqualsOperator];
+    }
+
+    static get supportedExpressions() {
+        return [ExactStringExpression];
+    }
+
+    test(card) {
+        return super.test(card.setType);
+    }
+}

package/src/keywords/StampKeyword.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 StampKeyword extends Keyword {
+    static get keys() {
+        return ['stamp'];
+    }
+
+    static get supportedOperators() {
+        return [IncludesOperator, EqualsOperator];
+    }
+
+    static get supportedExpressions() {
+        return [ExactStringExpression];
+    }
+
+    test(card) {
+        return super.test(card.stamp);
+    }
+}

package/src/keywords/ToughnessKeyword.js

@@ -0,0 +1,29 @@
+import { SearchSyntaxError } from 'sigil-sifter/core';
+import { NumericExpression } from 'sigil-sifter/expressions';
+import { Keyword } from 'sigil-sifter/keywords';
+import PowTouExpression from '../expressions/PowTouExpression.js';
+import { comparingPtAgainst } from '../core/helpers.js';
+
+export default class ToughnessKeyword extends Keyword {
+    static get keys() {
+        return ['toughness', 'tou'];
+    }
+
+    static get supportedExpressions() {
+        return [NumericExpression, PowTouExpression];
+    }
+
+    static parse(sifter, match, str) {
+        const keyword = super.parse(sifter, match, str);
+        if (comparingPtAgainst(keyword.expression, 'toughness'))
+            throw new SearchSyntaxError('Cannot compare toughness against itself.');
+        return keyword;
+    }
+
+    test(card) {
+        if (this.expression.constructor === PowTouExpression)
+            return card.pts.some(pt => super.test(pt));
+
+        return card.pts.some(pt => super.test(pt.toughness));
+    }
+}

package/src/keywords/WatermarkKeyword.js

@@ -0,0 +1,16 @@
+import { StringKeyword } from 'sigil-sifter/keywords';
+import { IncludesOperator } from 'sigil-sifter/operators';
+
+export default class WatermarkKeyword extends StringKeyword {
+    static get keys() {
+        return ['watermark'];
+    }
+
+    static get supportedOperators() {
+        return [IncludesOperator];
+    }
+
+    test(card) {
+        return card.watermarks.some(w => super.test(w));
+    }
+}

package/src/keywords/index.js

@@ -0,0 +1,65 @@
+import AbilityKeyword from './AbilityKeyword.js';
+import ArtistKeyword from './ArtistKeyword.js';
+import BannedKeyword from './BannedKeyword.js';
+import BorderKeyword from './BorderKeyword.js';
+import CardTypeKeyword from './CardTypeKeyword.js';
+import CollectorNumberKeyword from './CollectorNumberKeyword.js';
+import ColorKeyword from './ColorKeyword.js';
+import ColorIdentityKeyword from './ColorIdentityKeyword.js';
+import DevotionKeyword from './DevotionKeyword.js';
+import FlavorTextKeyword from './FlavorTextKeyword.js';
+import FormatKeyword from './FormatKeyword.js';
+import FrameKeyword from './FrameKeyword.js';
+import GameKeyword from './GameKeyword.js';
+import HasKeyword from './HasKeyword.js';
+import IsKeyword from './IsKeyword.js';
+import LanguageKeyword from './LanguageKeyword.js';
+import LoyaltyKeyword from './LoyaltyKeyword.js';
+import ManaCostKeyword from './ManaCostKeyword.js';
+import ManaValueKeyword from './ManaValueKeyword.js';
+import NameKeyword from './NameKeyword.js';
+import NotKeyword from './NotKeyword.js';
+import PowerKeyword from './PowerKeyword.js';
+import ProducesKeyword from './ProducesKeyword.js';
+import RarityKeyword from './RarityKeyword.js';
+import RestrictedKeyword from './RestrictedKeyword.js';
+import RulesTextKeyword from './RulesTextKeyword.js';
+import SetKeyword from './SetKeyword.js';
+import SetTypeKeyword from './SetTypeKeyword.js';
+import StampKeyword from './StampKeyword.js';
+import ToughnessKeyword from './ToughnessKeyword.js';
+import WatermarkKeyword from './WatermarkKeyword.js';
+
+export {
+    AbilityKeyword,
+    ArtistKeyword,
+    BannedKeyword,
+    BorderKeyword,
+    CardTypeKeyword,
+    CollectorNumberKeyword,
+    ColorKeyword,
+    ColorIdentityKeyword,
+    DevotionKeyword,
+    FlavorTextKeyword,
+    FormatKeyword,
+    FrameKeyword,
+    GameKeyword,
+    HasKeyword,
+    IsKeyword,
+    LanguageKeyword,
+    LoyaltyKeyword,
+    ManaCostKeyword,
+    ManaValueKeyword,
+    NameKeyword,
+    NotKeyword,
+    PowerKeyword,
+    ProducesKeyword,
+    RarityKeyword,
+    RestrictedKeyword,
+    RulesTextKeyword,
+    SetKeyword,
+    SetTypeKeyword,
+    StampKeyword,
+    ToughnessKeyword,
+    WatermarkKeyword,
+}