mana-scribe 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mana-scribe",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Library for parsing and querying Magic: The Gathering mana costs — with support for CMC, devotion, and color identity.",
   "keywords": [
     "mtg",
@@ -31,5 +31,11 @@
   "scripts": {
     "test": "jasmine --config=jasmine.json",
     "coverage": "c8 npm test"
-  }
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ]
 }

package/.c8rc.json

@@ -1,10 +0,0 @@
-{
-  "reporter": ["lcov", "text"],
-  "report-dir": "./coverage",
-  "exclude": [
-    "tests/**",
-    "node_modules/**"
-  ],
-  "check-coverage": false,
-  "skip_empty": true
-}

package/.github/workflows/tests.yml

@@ -1,37 +0,0 @@
-name: Node.js Tests
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [18.x, 24.x]
-
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-          cache: 'npm'
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Run tests with coverage
-        run: npm run coverage
-
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          files: ./coverage/lcov.info

package/jasmine.json

@@ -1,8 +0,0 @@
-{
-  "spec_dir": ".",
-  "spec_files": [
-    "tests/**/*.test.js"
-  ],
-  "random": false,
-  "stopSpecOnExpectationFailure": false
-}

package/tests/costs/ActivationCost.test.js

@@ -1,65 +0,0 @@
-import ActivationCost from '../../src/costs/ActivationCost.js';
-
-describe('ActivationCost (E2E)', () => {
-    describe('parsing non-mana symbols', () => {
-        it('parses tap symbol', () => {
-            const cost = ActivationCost.parse('T');
-            expect(cost.symbols.length).toBe(1);
-            expect(cost.symbols[0].type).toBe('tap');
-        });
-
-        it('parses untap symbol', () => {
-            const cost = ActivationCost.parse('{Q}');
-            expect(cost.symbols[0].type).toBe('untap');
-        });
-
-        it('parses energy symbol', () => {
-            const cost = ActivationCost.parse('{E}');
-            expect(cost.symbols[0].type).toBe('energy');
-        });
-    });
-
-    describe('mixed activation + mana costs', () => {
-        it('parses {2}{R}{T}', () => {
-            const cost = ActivationCost.parse('{2}{R}{T}');
-            const types = cost.symbols.map(s => s.type);
-            expect(types).toContain('genericMana');
-            expect(types).toContain('coloredMana');
-            expect(types).toContain('tap');
-            expect(cost.colors).toEqual(['R']);
-        });
-
-        it('parses {E}{W}{Q}', () => {
-            const cost = ActivationCost.parse('{E}{W}{Q}');
-            const types = cost.symbols.map(s => s.type);
-            expect(types).toEqual(['energy','coloredMana','untap']);
-            expect(cost.colors).toEqual(['W']);
-        });
-    });
-
-    describe('case insensitivity', () => {
-        it('parses lowercase {t}{q}{e}{w}', () => {
-            const cost = ActivationCost.parse('{t}{q}{e}{w}');
-            const types = cost.symbols.map(s => s.type);
-            expect(types).toEqual(['tap','untap','energy','coloredMana']);
-            expect(cost.colors).toEqual(['W']);
-        });
-    });
-
-    describe('serialization', () => {
-        it('serializes back to string with braces', () => {
-            const input = '{2}{U}{T}{E}';
-            const cost = ActivationCost.parse(input);
-            expect(cost.toString(true)).toBe(input);
-        });
-    });
-
-    describe('error handling', () => {
-        it('stops parsing at invalid symbol', () => {
-            const cost = ActivationCost.parse('{W}, T:');
-            expect(cost.symbols.length).toBe(1);
-            expect(cost.symbols[0].type).toBe('coloredMana');
-            expect(cost.remainingStr).toBe(', T:');
-        });
-    });
-});

package/tests/costs/Cost.test.js

@@ -1,27 +0,0 @@
-import Cost from '../../src/costs/Cost.js';
-import { NotImplementedError } from '../../src/customErrors.js';
-
-describe('Cost class', () => {
-    describe('allowedSymbols', () => {
-        it('should throw NotImplementedError when accessed', () => {
-            expect(() => {
-                Cost.allowedSymbols;
-            }).toThrowError(
-                NotImplementedError,
-                'Method "allowedSymbols" not implemented'
-            );
-        });
-    });
-
-    describe('parseNextSymbol', () => {
-        it('should throw NotImplementedError when trying to use allowedSymbols', () => {
-            class DummyCost extends Cost {}
-            expect(() => {
-                new DummyCost().parseNextSymbol('{X}');
-            }).toThrowError(
-                NotImplementedError,
-                'Method "allowedSymbols" not implemented'
-            );
-        });
-    });
-});

package/tests/costs/ManaCost.test.js

@@ -1,124 +0,0 @@
-import ManaCost from '../../src/costs/ManaCost.js';
-
-describe('ManaCost (E2E)', () => {
-    describe('parsing simple costs', () => {
-        it('parses generic numbers', () => {
-            const cost = ManaCost.parse('3');
-            expect(cost.symbols.length).toBe(1);
-            expect(cost.symbols[0].type).toBe('genericMana');
-            expect(cost.cmc).toBe(3);
-            expect(cost.colors).toEqual([]);
-        });
-
-        it('parses colored mana', () => {
-            const cost = ManaCost.parse('WUBRG');
-            expect(cost.symbols.map(s => s.type)).toEqual([
-                'coloredMana','coloredMana','coloredMana','coloredMana','coloredMana'
-            ]);
-            expect(cost.cmc).toBe(5);
-            expect(cost.colors.sort()).toEqual(['B','G','R','U','W']);
-        });
-    });
-
-    describe('hybrid and phyrexian costs', () => {
-        it('parses two-color hybrid', () => {
-            const cost = ManaCost.parse('{G/U}');
-            expect(cost.symbols.length).toBe(1);
-            expect(cost.symbols[0].type).toBe('twoColorHybridMana');
-            expect(cost.cmc).toBe(1);
-            expect(cost.colors.sort()).toEqual(['G','U']);
-        });
-
-        it('parses generic hybrid', () => {
-            const cost = ManaCost.parse('2/W');
-            expect(cost.symbols[0].type).toBe('genericHybridMana');
-            expect(cost.cmc).toBe(1);
-            expect(cost.colors).toEqual(['W']);
-        });
-
-        it('parses colored phyrexian', () => {
-            const cost = ManaCost.parse('R/H');
-            expect(cost.symbols[0].type).toBe('coloredPhyrexianMana');
-            expect(cost.cmc).toBe(1);
-            expect(cost.colors).toEqual(['R']);
-        });
-
-        it('parses colorless phyrexian', () => {
-            const cost = ManaCost.parse('{H}');
-            expect(cost.symbols[0].type).toBe('colorlessPhyrexianMana');
-            expect(cost.cmc).toBe(1);
-            expect(cost.colors).toEqual([]);
-        });
-    });
-
-    describe('special symbols', () => {
-        it('parses half mana', () => {
-            const cost = ManaCost.parse('|G');
-            expect(cost.symbols[0].type).toBe('halfColoredMana');
-            expect(cost.cmc).toBe(0.5);
-            expect(cost.colors).toEqual(['G']);
-        });
-
-        it('parses variable mana (X)', () => {
-            const cost = ManaCost.parse('X');
-            expect(cost.symbols[0].type).toBe('variableMana');
-            expect(cost.cmc).toBe(0);
-        });
-
-        it('parses infinity', () => {
-            const cost = ManaCost.parse('I');
-            expect(cost.symbols[0].type).toBe('infiniteMana');
-            expect(cost.cmc).toBe(Infinity);
-        });
-
-        it('parses snow mana', () => {
-            const cost = ManaCost.parse('S');
-            expect(cost.symbols[0].type).toBe('snowMana');
-            expect(cost.cmc).toBe(1);
-        });
-
-        it('parses colorless mana', () => {
-            const cost = ManaCost.parse('C');
-            expect(cost.symbols[0].type).toBe('colorlessMana');
-            expect(cost.cmc).toBe(1);
-        });
-    });
-
-    describe('complex costs', () => {
-        it('parses a mixed cost string', () => {
-            const cost = ManaCost.parse('{3}{W}{U}{B}{R}{G}{2/W}{G/U}{H}{S}{X}{C}');
-            const types = cost.symbols.map(s => s.type);
-            expect(types).toContain('genericMana');
-            expect(types).toContain('coloredMana');
-            expect(types).toContain('genericHybridMana');
-            expect(types).toContain('twoColorHybridMana');
-            expect(types).toContain('colorlessPhyrexianMana');
-            expect(types).toContain('snowMana');
-            expect(types).toContain('variableMana');
-            expect(types).toContain('colorlessMana');
-            expect(cost.cmc).toBe(13);
-            expect(cost.colors.sort()).toEqual(['B','G','R','U','W']);
-        });
-
-        it('computes devotion correctly', () => {
-            const cost = ManaCost.parse('WWWU');
-            expect(cost.getDevotionTo('W')).toBe(3);
-            expect(cost.getDevotionTo('U')).toBe(1);
-            expect(cost.getDevotionTo('B')).toBe(0);
-        });
-
-        it('serializes back to string', () => {
-            const input = '{3}{W}{U}{B}{R}{G}';
-            const cost = ManaCost.parse(input);
-            expect(cost.toString(true)).toBe(input);
-        });
-    });
-
-    describe('error handling', () => {
-        it('stops parsing at invalid symbol and sets remainingStr', () => {
-            const cost = ManaCost.parse('WQZ'); // W is valid, Q is not a mana symbol here
-            expect(cost.symbols[0].type).toBe('coloredMana');
-            expect(cost.remainingStr).toBe('QZ');
-        });
-    });
-});

package/tests/realWorld.test.js

@@ -1,80 +0,0 @@
-import ManaCost from '../src/costs/ManaCost.js';
-import ActivationCost from '../src/costs/ActivationCost.js';
-
-describe('Real-world integration', () => {
-    describe('ManaCost', () => {
-        it('Emrakul ({15})', () => {
-            const cost = ManaCost.parse('{15}');
-            expect(cost.cmc).toBe(15);
-            expect(cost.colors).toEqual([]);
-            expect(cost.remainingStr).toBe('');
-            expect(cost.toString(true)).toBe('{15}');
-        });
-
-        it('Niv-Mizzet Reborn ({W}{U}{B}{R}{G})', () => {
-            const cost = ManaCost.parse('{W}{U}{B}{R}{G}');
-            expect(cost.cmc).toBe(5);
-            expect(cost.colors.sort()).toEqual(['B','G','R','U','W']);
-            expect(cost.getDevotionTo('W')).toBe(1);
-            expect(cost.remainingStr).toBe('');
-        });
-
-        it('Phyrexian Metamorph ({3}{U/P} as {3}{U/H})', () => {
-            const cost = ManaCost.parse('{3}{U/H}');
-            expect(cost.cmc).toBe(4);
-            expect(cost.colors).toEqual(['U']);
-            expect(cost.remainingStr).toBe('');
-        });
-
-        it('cost with trailing reminder text', () => {
-            const str = '{1}{U}{U}{U} (choose two…)';
-            const cost = ManaCost.parse(str);
-            expect(cost.cmc).toBe(4);
-            expect(cost.colors).toEqual(['U']);
-            expect(cost.remainingStr).toBe(' (choose two…)');
-        });
-    });
-
-    describe('ActivationCost', () => {
-        it('tap then text', () => {
-            const str = '{T}: Add {G}.';
-            const cost = ActivationCost.parse(str);
-            expect(cost.symbols.map(s => s.type)).toEqual(['tap']);
-            expect(cost.colors).toEqual([]);
-            expect(cost.remainingStr).toBe(': Add {G}.');
-        });
-
-        it('mana, then comma and tap + text (stops at comma)', () => {
-            const str = '{1}{B}, {T}, Discard a card: Create a 2/2 Zombie.';
-            const cost = ActivationCost.parse(str);
-            expect(cost.symbols.map(s => s.type)).toEqual(['genericMana','coloredMana']);
-            expect(cost.colors).toEqual(['B']);
-            expect(cost.remainingStr).toBe(', {T}, Discard a card: Create a 2/2 Zombie.');
-        });
-
-        it('untap then text (stops at comma)', () => {
-            const str = '{Q}, Pay 2 life: Untap target creature.';
-            const cost = ActivationCost.parse(str);
-            expect(cost.symbols.map(s => s.type)).toEqual(['untap']);
-            expect(cost.colors).toEqual([]);
-            expect(cost.remainingStr).toBe(', Pay 2 life: Untap target creature.');
-        });
-
-        it('energy then text (stops at comma)', () => {
-            const str = '{E}, {T}: Deal 1 damage.';
-            const cost = ActivationCost.parse(str);
-            expect(cost.symbols.map(s => s.type)).toEqual(['energy']);
-            expect(cost.colors).toEqual([]);
-            expect(cost.remainingStr).toBe(', {T}: Deal 1 damage.');
-        });
-
-        it('mixed shortform + braces then text (stops at comma)', () => {
-            const str = '2R, {T}: Ping.';
-            const cost = ActivationCost.parse(str);
-            // Only "2" then "R" get parsed; stops at the comma before {T}
-            expect(cost.symbols.map(s => s.type)).toEqual(['genericMana','coloredMana']);
-            expect(cost.colors).toEqual(['R']);
-            expect(cost.remainingStr).toBe(', {T}: Ping.');
-        });
-    });
-});

package/tests/symbols/ColoredManaSymbol.js

@@ -1,62 +0,0 @@
-import ColoredManaSymbol from '../../src/symbols/ColoredManaSymbol.js';
-
-describe('ColoredManaSymbol', () => {
-    describe('fromString()', () => {
-        it('creates a symbol from shortform', () => {
-            const sym = ColoredManaSymbol.fromString('R');
-            expect(sym).toBeInstanceOf(ColoredManaSymbol);
-            expect(sym.raw).toBe('R');
-            expect(sym.remainingStr).toBe('');
-        });
-
-        it('creates a symbol from scryfall braces', () => {
-            const sym = ColoredManaSymbol.fromString('{g}');
-            expect(sym.raw).toBe('G'); // normalized to uppercase
-            expect(sym.remainingStr).toBe('');
-        });
-
-        it('throws for invalid input', () => {
-            expect(() => ColoredManaSymbol.fromString('X')).toThrow();
-            expect(() => ColoredManaSymbol.fromString('{C}')).toThrow();
-        });
-    });
-
-    describe('properties', () => {
-        it('has type coloredMana', () => {
-            expect(ColoredManaSymbol.fromString('U').type).toBe('coloredMana');
-        });
-
-        it('cmcValue is always 1', () => {
-            for (const c of 'WUBRG') {
-                expect(ColoredManaSymbol.fromString(c).cmcValue()).toBe(1);
-            }
-        });
-
-        it('reports correct colors', () => {
-            for (const c of 'WUBRG') {
-                expect(ColoredManaSymbol.fromString(c).colors).toEqual([c]);
-            }
-        });
-
-        it('devotion to its color is 1, others 0', () => {
-            const sym = ColoredManaSymbol.fromString('U');
-            expect(sym.devotion('U')).toBe(1);
-            expect(sym.devotion('R')).toBe(0);
-        });
-    });
-
-    describe('inherited methods', () => {
-        it('apply() pushes to array', () => {
-            const arr = [];
-            const sym = ColoredManaSymbol.fromString('W');
-            sym.apply(arr);
-            expect(arr[0]).toBe(sym);
-        });
-
-        it('toString() outputs correctly', () => {
-            const sym = ColoredManaSymbol.fromString('G');
-            expect(sym.toString(false)).toBe('G');
-            expect(sym.toString(true)).toBe('{G}');
-        });
-    });
-});

package/tests/symbols/ColoredPhyrexianManaSymbol.test.js

@@ -1,69 +0,0 @@
-import ColoredPhyrexianManaSymbol from '../../src/symbols/ColoredPhyrexianManaSymbol.js';
-
-describe('ColoredPhyrexianManaSymbol', () => {
-    describe('fromString()', () => {
-        it('creates a symbol from H/W and W/H (braced and shortform)', () => {
-            const s1 = ColoredPhyrexianManaSymbol.fromString('H/W');
-            expect(s1.raw).toBe('H/W');
-            expect(s1.colors).toEqual(['W']);
-
-            const s2 = ColoredPhyrexianManaSymbol.fromString('{W/H}');
-            expect(s2.raw).toBe('W/H');
-            expect(s2.colors).toEqual(['W']);
-        });
-
-        it('is case insensitive', () => {
-            const s1 = ColoredPhyrexianManaSymbol.fromString('{h/b}');
-            expect(s1.raw).toBe('H/B');
-            expect(s1.colors).toEqual(['B']);
-
-            const s2 = ColoredPhyrexianManaSymbol.fromString('u/h');
-            expect(s2.raw).toBe('U/H');
-            expect(s2.colors).toEqual(['U']);
-        });
-
-        it('throws for invalid input', () => {
-            expect(() => ColoredPhyrexianManaSymbol.fromString('{U}')).toThrow();
-            expect(() => ColoredPhyrexianManaSymbol.fromString('2/W')).toThrow();
-            expect(() => ColoredPhyrexianManaSymbol.fromString('{C}')).toThrow();
-        });
-
-        for (const c of 'WUBRG') {
-            it(`parses H/${c} and ${c}/H correctly`, () => {
-                const sym1 = ColoredPhyrexianManaSymbol.fromString(`H/${c}`);
-                expect(sym1.colors).toEqual([c]);
-
-                const sym2 = ColoredPhyrexianManaSymbol.fromString(`${c}/H`);
-                expect(sym2.colors).toEqual([c]);
-            });
-        }
-
-    });
-
-    describe('properties', () => {
-        it('has type coloredPhyrexianMana', () => {
-            const sym = ColoredPhyrexianManaSymbol.fromString('H/G');
-            expect(sym.type).toBe('coloredPhyrexianMana');
-        });
-
-        it('cmcValue is always 1', () => {
-            expect(ColoredPhyrexianManaSymbol.fromString('H/U').cmcValue()).toBe(1);
-            expect(ColoredPhyrexianManaSymbol.fromString('B/H').cmcValue()).toBe(1);
-        });
-    });
-
-    describe('inherited methods', () => {
-        it('apply() pushes to array', () => {
-            const arr = [];
-            const sym = ColoredPhyrexianManaSymbol.fromString('H/R');
-            sym.apply(arr);
-            expect(arr[0]).toBe(sym);
-        });
-
-        it('toString() outputs correctly', () => {
-            const sym = ColoredPhyrexianManaSymbol.fromString('W/H');
-            expect(sym.toString(false)).toBe('W/H');
-            expect(sym.toString(true)).toBe('{W/H}');
-        });
-    });
-});

package/tests/symbols/ColorlessManaSymbol.test.js

@@ -1,56 +0,0 @@
-import ColorlessManaSymbol from '../../src/symbols/ColorlessManaSymbol.js';
-
-describe('ColorlessManaSymbol', () => {
-    describe('fromString()', () => {
-        it('creates a symbol from shortform C', () => {
-            const sym = ColorlessManaSymbol.fromString('C');
-            expect(sym).toBeInstanceOf(ColorlessManaSymbol);
-            expect(sym.raw).toBe('C');
-            expect(sym.remainingStr).toBe('');
-        });
-
-        it('creates a symbol from scryfall style {C}', () => {
-            const sym = ColorlessManaSymbol.fromString('{c}');
-            expect(sym.raw).toBe('C'); // uppercased
-            expect(sym.remainingStr).toBe('');
-        });
-
-        it('throws for invalid input', () => {
-            expect(() => ColorlessManaSymbol.fromString('{X}')).toThrow();
-            expect(() => ColorlessManaSymbol.fromString('W')).toThrow();
-            expect(() => ColorlessManaSymbol.fromString('')).toThrow();
-        });
-    });
-
-    describe('properties', () => {
-        it('has type colorlessMana', () => {
-            const sym = ColorlessManaSymbol.fromString('C');
-            expect(sym.type).toBe('colorlessMana');
-        });
-
-        it('cmcValue is always 1', () => {
-            const sym = ColorlessManaSymbol.fromString('{C}');
-            expect(sym.cmcValue()).toBe(1);
-        });
-
-        it('colors is always empty', () => {
-            const sym = ColorlessManaSymbol.fromString('C');
-            expect(sym.colors).toEqual([]);
-        });
-    });
-
-    describe('inherited methods', () => {
-        it('apply() pushes to array', () => {
-            const arr = [];
-            const sym = ColorlessManaSymbol.fromString('C');
-            sym.apply(arr);
-            expect(arr[0]).toBe(sym);
-        });
-
-        it('toString() outputs correctly', () => {
-            const sym = ColorlessManaSymbol.fromString('C');
-            expect(sym.toString(false)).toBe('C');
-            expect(sym.toString(true)).toBe('{C}');
-        });
-    });
-});

package/tests/symbols/ColorlessPhyrexianManaSymbol.test.js

@@ -1,61 +0,0 @@
-import ColorlessPhyrexianManaSymbol from '../../src/symbols/ColorlessPhyrexianManaSymbol.js';
-
-describe('ColorlessPhyrexianManaSymbol', () => {
-    describe('fromString()', () => {
-        it('creates a symbol from H/C and C/H (shortform and braced)', () => {
-            expect(ColorlessPhyrexianManaSymbol.fromString('H/C').raw).toBe('H/C');
-            expect(ColorlessPhyrexianManaSymbol.fromString('{c/h}').raw).toBe('C/H');
-        });
-
-        it('creates a symbol from H (shortform and braced)', () => {
-            expect(ColorlessPhyrexianManaSymbol.fromString('H').raw).toBe('H');
-            expect(ColorlessPhyrexianManaSymbol.fromString('{h}').raw).toBe('H');
-        });
-
-        it('is case insensitive', () => {
-            const sym = ColorlessPhyrexianManaSymbol.fromString('{h/c}');
-            expect(sym.raw).toBe('H/C');
-        });
-
-        it('throws for invalid input', () => {
-            expect(() => ColorlessPhyrexianManaSymbol.fromString('C')).toThrow();
-            expect(() => ColorlessPhyrexianManaSymbol.fromString('{X}')).toThrow();
-        });
-    });
-
-    describe('properties', () => {
-        it('has type colorlessPhyrexianMana', () => {
-            const sym = ColorlessPhyrexianManaSymbol.fromString('H');
-            expect(sym.type).toBe('colorlessPhyrexianMana');
-        });
-
-        it('cmcValue is always 1', () => {
-            const sym = ColorlessPhyrexianManaSymbol.fromString('H/C');
-            expect(sym.cmcValue()).toBe(1);
-        });
-
-        it('colors is always empty', () => {
-            const sym = ColorlessPhyrexianManaSymbol.fromString('C/H');
-            expect(sym.colors).toEqual([]);
-        });
-    });
-
-    describe('inherited methods', () => {
-        it('apply() pushes to array', () => {
-            const arr = [];
-            const sym = ColorlessPhyrexianManaSymbol.fromString('H');
-            sym.apply(arr);
-            expect(arr[0]).toBe(sym);
-        });
-
-        it('toString() outputs correctly', () => {
-            const sym1 = ColorlessPhyrexianManaSymbol.fromString('H/C');
-            expect(sym1.toString(false)).toBe('H/C');
-            expect(sym1.toString(true)).toBe('{H/C}');
-
-            const sym2 = ColorlessPhyrexianManaSymbol.fromString('H');
-            expect(sym2.toString(false)).toBe('H');
-            expect(sym2.toString(true)).toBe('{H}');
-        });
-    });
-});