@sigil-sifter/magic 1.0.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Colin A
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,95 @@
+# @sigil-sifter/magic
+
+This is a module which provides the keywords, expressions, and data extensions to filter Magic: The Gathering cards with sigil-sifter.
+
+## installation
+```bash
+npm i @sigil-sifter/magic
+```
+
+## usage
+```js
+import Sifter from 'sigil-sifter';
+import Magic from '@sigil-sifter/magic';
+import { MagicCard } from '@sigil-sifter/magic/core';
+
+class CardClass extends MagicCard {
+    // implement your custom card data wrapper here
+    // see the base MagicCard class for all methods
+    get names() {
+        return [this.card.name];
+    }
+}
+
+// you can pass the library data to override default
+// behavior or enable certain keywords
+const GameData = {
+    colors: null,
+    guilds: null,
+    gameFormats: null,
+    abilityWords: null,
+    languages: null,
+    rarities: null,
+    sets: null
+};
+
+Magic(sifter, CardClass, GameData);
+
+// invoke sifter to filter an array of cards
+const cards = [{
+    name: 'Black Lotus'
+}, {
+    name: 'Mox Emerald'
+}, {
+    name: 'Mox Sapphire'
+}]
+sifter.filter(cards, 'black lotus'); 
+```
+
+## implemented keywords
+Pretty much every keyword defined on the [scryfall search syntax](https://scryfall.com/docs/syntax) page is implemented by this module. You can use the `@sigil-sifter/magic-scryfall` package with this module to search downloaded scryfall card data directly.
+
+## unimplemented keywords
+
+**TAGGING**
+- otag/oracletag/function
+- art/atag/arttag
+
+**PRICING**
+- usd
+- eur
+- tix
+
+**SET**
+- block
+- year
+- date
+
+**PRINTINGS**
+- in
+- sets
+- cheapest
+- prints
+
+**OTHERS**
+- fulloracle, ~ support in oracle text
+- artists
+- illustrations
+- is:hires
+- new
+- is:reserved
+- is:duelcommander
+- is:commander
+- is:brawler
+- is:companion
+- cube
+- is:\[product]
+- include:extras
+- is:funny
+- is:bear
+- is:\[landgroup]
+- is:masterpiece
+- order
+- prefer
+- direction
+- unique

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@sigil-sifter/magic",
+  "version": "1.0.0",
+  "description": "",
+  "license": "MIT",
+  "author": "mator",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./core": "./src/core/index.js"
+  },
+  "scripts": {
+    "prepublishOnly": "cp ../../LICENSE ."
+  },
+  "dependencies": {
+    "mana-scribe": "^1.1.0"
+  },
+  "peerDependencies": {
+    "sigil-sifter": "^1.0.0"
+  },
+  "devDependencies": {
+    "sigil-sifter": "^1.0.0"
+  },
+  "files": [
+    "src/*",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/core/MagicCard.js

@@ -0,0 +1,250 @@
+import { NotImplementedError } from 'sigil-sifter/core';
+
+const permanentTypes = [
+    'land', 'creature', 'artifact', 'enchantment',
+    'planeswalker', 'battle', 'summon', 'eaturecray'
+];
+
+const spellTypes = [
+    'instant', 'sorcery', 'creature', 'artifact', 'enchantment',
+    'planeswalker', 'battle', 'summon', 'eaturecray'
+];
+
+const historicTypes = ['artifact', 'saga', 'legendary'];
+const partyTypes = ['wizard', 'rogue', 'warrior', 'cleric', 'rogue'];
+
+export default class MagicCard {
+    constructor(sifter, card) {
+        this.sifter = sifter;
+        this.card = card;
+        this._cache = {};
+    }
+
+    cache(key, initFn) {
+        if (!this._cache.hasOwnProperty(key))
+            this._cache[key] = initFn();
+        return this._cache[key];
+    }
+
+    get artists() {
+        throw new NotImplementedError();
+    }
+
+    get banned() {
+        throw new NotImplementedError();
+    }
+
+    get border() {
+        throw new NotImplementedError();
+    }
+
+    get collectorNumber() {
+        throw new NotImplementedError();
+    }
+
+    get colors() {
+        throw new NotImplementedError();
+    }
+
+    get colorIdentity() {
+        throw new NotImplementedError();
+    }
+
+    get flavorTexts() {
+        throw new NotImplementedError();
+    }
+
+    get formats() {
+        throw new NotImplementedError();
+    }
+
+    get frame() {
+        throw new NotImplementedError();
+    }
+
+    get frameEffects() {
+        throw new NotImplementedError();
+    }
+
+    get game() {
+        throw new NotImplementedError();
+    }
+
+    get keywords() {
+        throw new NotImplementedError();
+    }
+
+    get loyalty() {
+        throw new NotImplementedError();
+    }
+
+    get manaValues() {
+        throw new NotImplementedError();
+    }
+
+    get produces() {
+        throw new NotImplementedError();
+    }
+
+    get pts() {
+        throw new NotImplementedError();
+    }
+
+    get rarity() {
+        throw new NotImplementedError();
+    }
+
+    get restricted() {
+        throw new NotImplementedError();
+    }
+
+    get rulesTexts() {
+        throw new NotImplementedError();
+    }
+
+    get set() {
+        throw new NotImplementedError();
+    }
+
+    get setType() {
+        throw new NotImplementedError();
+    }
+
+    get stamp() {
+        throw new NotImplementedError();
+    }
+
+    get typeLines() {
+        throw new NotImplementedError();
+    }
+
+    get typeParts() {
+        return this.typeLines.flatMap(typeLine => {
+            return typeLine.toLowerCase().split(/\s+/);
+        });
+    }
+
+    get watermarks() {
+        throw new NotImplementedError();
+    }
+
+    get hasIndicator() {
+        throw new NotImplementedError();
+    }
+
+    get hasWatermark() {
+        return this.watermarks.length > 0;
+    }
+
+    get isBooster() {
+        throw new NotImplementedError();
+    }
+
+    get isDFC() {
+        throw new NotImplementedError();
+    }
+
+    get isEtched() {
+        throw new NotImplementedError();
+    }
+
+    get isFlip() {
+        throw new NotImplementedError();
+    }
+
+    get isFoil() {
+        throw new NotImplementedError();
+    }
+
+    get isFrenchVanilla() {
+        throw new NotImplementedError();
+    }
+
+    get isFullArt() {
+        throw new NotImplementedError();
+    }
+
+    get isGlossy() {
+        throw new NotImplementedError();
+    }
+
+    get isHistoric() {
+        return this.typeParts.some(part => historicTypes.includes(part));
+    }
+
+    get isHybrid() {
+        throw new NotImplementedError();
+    }
+
+    get isLeveler() {
+        return this.keywords.includes('level up');
+    }
+
+    get isMDFC() {
+        throw new NotImplementedError();
+    }
+
+    get isMeld() {
+        throw new NotImplementedError();
+    }
+
+    get isModal() {
+        throw new NotImplementedError();
+    }
+
+    get isNonFoil() {
+        throw new NotImplementedError();
+    }
+
+    get isParty() {
+        return this.typeParts.some(part => partyTypes.includes(part));
+    }
+
+    get isPermanent() {
+        return this.typeParts.some(part => permanentTypes.includes(part));
+    }
+
+    get isPhyrexian() {
+        throw new NotImplementedError();
+    }
+
+    get isPromo() {
+        throw new NotImplementedError();
+    }
+
+    get isReprint() {
+        throw new NotImplementedError();
+    }
+
+    get isReserved() {
+        throw new NotImplementedError();
+    }
+
+    get isSpell() {
+        return this.typeParts.some(part => spellTypes.includes(part));
+    }
+
+    get isSplit() {
+        throw new NotImplementedError();
+    }
+
+    get isSpotlight() {
+        throw new NotImplementedError();
+    }
+
+    get isTextless() {
+        throw new NotImplementedError();
+    }
+
+    get isTransform() {
+        throw new NotImplementedError();
+    }
+
+    get isUniversesBeyond() {
+        throw new NotImplementedError();
+    }
+
+    get isVanilla() {
+        return this.rulesTexts.some(rt => rt === '');
+    }
+}

package/src/core/helpers.js

@@ -0,0 +1,6 @@
+import PowTouExpression from '../expressions/PowTouExpression.js';
+
+export function comparingPtAgainst(expression, mode) {
+    return expression.constructor === PowTouExpression
+        && expression.mode === mode;
+}

package/src/core/index.js

@@ -0,0 +1,3 @@
+import MagicCard from './MagicCard.js';
+
+export { MagicCard };

package/src/data/abilityWords.js

@@ -0,0 +1,66 @@
+export default [
+    "Eerie",
+    "Battalion",
+    "Bloodrush",
+    "Channel",
+    "Chroma",
+    "Cohort",
+    "Constellation",
+    "Converge",
+    "Delirium",
+    "Domain",
+    "Fateful hour",
+    "Ferocious",
+    "Formidable",
+    "Grandeur",
+    "Hellbent",
+    "Heroic",
+    "Imprint",
+    "Inspired",
+    "Join forces",
+    "Kinship",
+    "Landfall",
+    "Lieutenant",
+    "Metalcraft",
+    "Morbid",
+    "Parley",
+    "Radiance",
+    "Raid",
+    "Rally",
+    "Spell mastery",
+    "Strive",
+    "Sweep",
+    "Tempting offer",
+    "Threshold",
+    "Will of the council",
+    "Adamant",
+    "Addendum",
+    "Council's dilemma",
+    "Eminence",
+    "Enrage",
+    "Hero's Reward",
+    "Kinfall",
+    "Landship",
+    "Legacy",
+    "Revolt",
+    "Underdog",
+    "Undergrowth",
+    "Void",
+    "Descend",
+    "Fathomless descent",
+    "Magecraft",
+    "Teamwork",
+    "Pack tactics",
+    "Coven",
+    "Alliance",
+    "Corrupted",
+    "Secret council",
+    "Celebration",
+    "Paradox",
+    "Will of the Planeswalkers",
+    "Survival",
+    "Flurry",
+    "Valiant",
+    "Start your engines!",
+    "Renew"
+];

package/src/data/colors.js

@@ -0,0 +1,15 @@
+const color = (id, name) => ({
+    id,
+    name,
+    expr: new RegExp('^' + name + '$', 'i'),
+    colorChars: [id]
+});
+
+export default [
+    color('W', 'White'),
+    color('U', 'Blue'),
+    color('B', 'Black'),
+    color('R', 'Red'),
+    color('G', 'Green'),
+    color('C', 'Colorless'),
+];

package/src/data/gameFormats.js

@@ -0,0 +1,25 @@
+const format = (name) => ({ name });
+
+export default [
+    format('standard'),
+    format('future'),
+    format('historic'),
+    format('timeless'),
+    format('gladiator'),
+    format('pioneer'),
+    format('modern'),
+    format('legacy'),
+    format('pauper'),
+    format('vintage'),
+    format('penny'),
+    format('commander'),
+    format('oathbreaker'),
+    format('standardbrawl'),
+    format('brawl'),
+    format('alchemy'),
+    format('paupercommander'),
+    format('duel'),
+    format('oldschool'),
+    format('premodern'),
+    format('predh'),
+];

package/src/data/games.js

@@ -0,0 +1,5 @@
+export default [
+    { name: 'Paper' },
+    { name: 'MTGO' },
+    { name: 'Arena' },
+];

package/src/data/guilds.js

@@ -0,0 +1,33 @@
+const colorCombo = (name, colors) => ({
+    name,
+    expr: new RegExp('^' + name + '$', 'i'),
+    colorChars: colors.split('')
+});
+
+export default [
+    colorCombo('Azorius', 'WU'),
+    colorCombo('Dimir', 'UB'),
+    colorCombo('Rakdos', 'BR'),
+    colorCombo('Gruul', 'RG'),
+    colorCombo('Selesnya', 'WG'),
+    colorCombo('Orzhov', 'WB'),
+    colorCombo('Izzet', 'UR'),
+    colorCombo('Golgari', 'BG'),
+    colorCombo('Boros', 'WR'),
+    colorCombo('Simic', 'UG'),
+    colorCombo('Bant', 'WUG'),
+    colorCombo('Esper', 'WUB'),
+    colorCombo('Grixis', 'UBR'),
+    colorCombo('Jund', 'BRG'),
+    colorCombo('Naya', 'WRG'),
+    colorCombo('Abzan', 'WBG'),
+    colorCombo('Jeskai', 'WUR'),
+    colorCombo('Sultai', 'UBG'),
+    colorCombo('Mardu', 'WBR'),
+    colorCombo('Temur', 'URG'),
+    colorCombo('Chaos', 'UBRG'),
+    colorCombo('Aggression', 'WBRG'),
+    colorCombo('Altruism', 'WURG'),
+    colorCombo('Growth', 'WUBG'),
+    colorCombo('Artifice', 'WUBR'),
+];

package/src/data/languages.js

@@ -0,0 +1,30 @@
+const language = (acronym, name, expr) => ({
+    acronyms: Array.isArray(acronym) ? acronym : [acronym],
+    name,
+    expr: expr || new RegExp('^' + name + '$', 'i')
+});
+
+// https://cran.r-project.org/web/packages/scryr/vignettes/languages.html
+export default [
+    language('en', 'English'),
+    language('es', 'Spanish'),
+    language('fr', 'French'),
+    language('de', 'German'),
+    language('it', 'Italian'),
+    language('pt', 'Portuguese'),
+    language(['ja', 'jp'], 'Japanese'),
+    language(['ko', 'kr'], 'Korean'),
+    language('ru', 'Russian'),
+    language(['zhs', 'cs'], 'Chinese (Simplified)',
+        /^(Chinese \(Simplified\)|Simplified Chinese)$/i
+    ),
+    language(['zht', 'ct'], 'Chinese (Traditional)',
+        /^(Chinese \(Traditional\)|Traditional Chinese)$/i
+    ),
+    language('he', 'Hebrew'),
+    language('la', 'Latin'),
+    language('grc', 'Ancient Greek'),
+    language('ar', 'Arabic'),
+    language('sa', 'Sanskrit'),
+    language('ph', 'Phyrexian')
+];

package/src/data/rarities.js

@@ -0,0 +1,25 @@
+export default [{
+    index: 0,
+    char: 'C',
+    name: 'Common',
+}, {
+    index: 1,
+    char: 'U',
+    name: 'Uncommon',
+}, {
+    index: 2,
+    char: 'R',
+    name: 'Rare'
+}, {
+    index: 3,
+    char: 'M',
+    name: 'Mythic'
+}, {
+    index: 3,
+    char: 'S',
+    name: 'Special'
+}, {
+    index: 4,
+    char: 'B',
+    name: 'Bonus'
+}];

package/src/expressions/ArrayLengthExpression.js

@@ -0,0 +1,15 @@
+import { NumericExpression } from 'sigil-sifter/expressions';
+
+export default class ArrayLengthExpression extends NumericExpression {
+    equals(val) {
+        return val.length === this.value;
+    }
+
+    greaterThan(val) {
+        return val.length > this.value;
+    }
+
+    lessThan(val) {
+        return val.length < this.value;
+    }
+}

package/src/expressions/ColorExpression.js

@@ -0,0 +1,40 @@
+import { Expression } from 'sigil-sifter/expressions';
+
+export default class ColorExpression extends Expression {
+    static match(sifter, str) {
+        return str.match(sifter.ColorExtension.colorNamesExpr)
+            || str.match(/^([wubrgc]+)/i);
+    }
+
+    constructor(sifter, match, str) {
+        super(sifter, match, str);
+        this.value = match[0];
+        this.colors = sifter.ColorExtension.resolveColors(this.value);
+        this.colorless = this.colors.includes('C');
+        if (this.colorless && this.colors.length > 1)
+            throw new Error('A card cannot be both colorless and colored.');
+    }
+
+    includes(val) {
+        if (this.colorless) return val.length === 0;
+        return this.colors.every(c => val.includes(c));
+    }
+
+    equals(val) {
+        if (this.colorless) return val.length === 0;
+        return val.length === this.colors.length
+            && val.every(c => this.colors.includes(c));
+    }
+
+    greaterThan(val) {
+        if (this.colorless) return val.length > 0;
+        return val.length > this.colors.length
+            && this.colors.every(c => val.includes(c));
+    }
+
+    lessThan(val) {
+        if (this.colorless) return false;
+        return val.length < this.colors.length
+            && val.every(c => this.colors.includes(c));
+    }
+}