mana-scribe 1.0.0

package/tests/symbols/ThreeColorHybridManaSymbol.test.js

@@ -0,0 +1,68 @@
+import ThreeColorHybridManaSymbol from '../../src/symbols/ThreeColorHybridManaSymbol.js';
+
+describe('ThreeColorHybridManaSymbol', () => {
+    describe('fromString()', () => {
+        it('creates a symbol from three-color hybrid (braced and shortform)', () => {
+            const sym1 = ThreeColorHybridManaSymbol.fromString('{W/U/B}');
+            expect(sym1.raw).toBe('W/U/B');
+            expect(sym1.colors.sort()).toEqual(['B','U','W']);
+
+            const sym2 = ThreeColorHybridManaSymbol.fromString('R/G/U');
+            expect(sym2.raw).toBe('R/G/U');
+            expect(sym2.colors.sort()).toEqual(['G','R','U']);
+        });
+
+        it('is case insensitive', () => {
+            const sym = ThreeColorHybridManaSymbol.fromString('{w/u/g}');
+            expect(sym.raw).toBe('W/U/G');
+            expect(sym.colors.sort()).toEqual(['G','U','W']);
+        });
+
+        it('throws for invalid input', () => {
+            // fewer than 3 colors
+            expect(() => ThreeColorHybridManaSymbol.fromString('W/U')).toThrow();
+            // duplicates
+            expect(() => ThreeColorHybridManaSymbol.fromString('W/U/W')).toThrow();
+            // invalid char
+            expect(() => ThreeColorHybridManaSymbol.fromString('W/U/C')).toThrow();
+        });
+    });
+
+    describe('properties', () => {
+        it('has type threeColorHybridMana', () => {
+            const sym = ThreeColorHybridManaSymbol.fromString('W/U/B');
+            expect(sym.type).toBe('threeColorHybridMana');
+        });
+
+        it('cmcValue is always 1', () => {
+            const sym = ThreeColorHybridManaSymbol.fromString('{W/U/B}');
+            expect(sym.cmcValue()).toBe(1);
+        });
+    });
+
+    describe('inherited methods', () => {
+        it('apply() pushes to array', () => {
+            const arr = [];
+            const sym = ThreeColorHybridManaSymbol.fromString('W/U/B');
+            sym.apply(arr);
+            expect(arr[0]).toBe(sym);
+        });
+
+        it('toString() outputs correctly', () => {
+            const sym = ThreeColorHybridManaSymbol.fromString('{W/U/B}');
+            expect(sym.toString(false)).toBe('W/U/B');
+            expect(sym.toString(true)).toBe('{W/U/B}');
+        });
+    });
+
+    describe('roundtrip', () => {
+        it('parses and serializes symmetrically', () => {
+            const input = '{W/U/B}';
+            const sym1 = ThreeColorHybridManaSymbol.fromString(input);
+            const str = sym1.toString(true);
+            const sym2 = ThreeColorHybridManaSymbol.fromString(str);
+            expect(sym2.raw).toBe('W/U/B');
+            expect(sym2.colors.sort()).toEqual(['B','U','W']);
+        });
+    });
+});

package/tests/symbols/TwoColorHybridManaSymbol.test.js

@@ -0,0 +1,68 @@
+import TwoColorHybridManaSymbol from '../../src/symbols/TwoColorHybridManaSymbol.js';
+
+describe('TwoColorHybridManaSymbol', () => {
+    describe('fromString()', () => {
+        it('creates a symbol from two-color hybrid (braced and shortform)', () => {
+            const sym1 = TwoColorHybridManaSymbol.fromString('{W/U}');
+            expect(sym1.raw).toBe('W/U');
+            expect(sym1.colors.sort()).toEqual(['U','W']);
+
+            const sym2 = TwoColorHybridManaSymbol.fromString('R/G');
+            expect(sym2.raw).toBe('R/G');
+            expect(sym2.colors.sort()).toEqual(['G','R']);
+        });
+
+        it('is case insensitive', () => {
+            const sym = TwoColorHybridManaSymbol.fromString('{b/r}');
+            expect(sym.raw).toBe('B/R');
+            expect(sym.colors.sort()).toEqual(['B','R']);
+        });
+
+        it('throws for invalid input', () => {
+            // single color
+            expect(() => TwoColorHybridManaSymbol.fromString('W')).toThrow();
+            // duplicates
+            expect(() => TwoColorHybridManaSymbol.fromString('W/W')).toThrow();
+            // invalid char
+            expect(() => TwoColorHybridManaSymbol.fromString('W/C')).toThrow();
+        });
+    });
+
+    describe('properties', () => {
+        it('has type twoColorHybridMana', () => {
+            const sym = TwoColorHybridManaSymbol.fromString('W/U');
+            expect(sym.type).toBe('twoColorHybridMana');
+        });
+
+        it('cmcValue is always 1', () => {
+            const sym = TwoColorHybridManaSymbol.fromString('{R/G}');
+            expect(sym.cmcValue()).toBe(1);
+        });
+    });
+
+    describe('inherited methods', () => {
+        it('apply() pushes to array', () => {
+            const arr = [];
+            const sym = TwoColorHybridManaSymbol.fromString('W/U');
+            sym.apply(arr);
+            expect(arr[0]).toBe(sym);
+        });
+
+        it('toString() outputs correctly', () => {
+            const sym = TwoColorHybridManaSymbol.fromString('{U/B}');
+            expect(sym.toString(false)).toBe('U/B');
+            expect(sym.toString(true)).toBe('{U/B}');
+        });
+    });
+
+    describe('roundtrip', () => {
+        it('parses and serializes symmetrically', () => {
+            const input = '{G/R}';
+            const sym1 = TwoColorHybridManaSymbol.fromString(input);
+            const str = sym1.toString(true);
+            const sym2 = TwoColorHybridManaSymbol.fromString(str);
+            expect(sym2.raw).toBe('G/R');
+            expect(sym2.colors.sort()).toEqual(['G','R']);
+        });
+    });
+});

package/tests/symbols/UntapSymbol.test.js

@@ -0,0 +1,74 @@
+import UntapSymbol from '../../src/symbols/UntapSymbol.js';
+
+describe('UntapSymbol', () => {
+    describe('fromString()', () => {
+        it('creates a symbol from Q (shortform and braced)', () => {
+            const sym1 = UntapSymbol.fromString('Q');
+            expect(sym1.raw).toBe('Q');
+            expect(sym1.type).toBe('untap');
+            expect(sym1.cmcValue()).toBe(0);
+            expect(sym1.colors).toEqual([]);
+
+            const sym2 = UntapSymbol.fromString('{Q}');
+            expect(sym2.raw).toBe('Q');
+            expect(sym2.type).toBe('untap');
+            expect(sym2.cmcValue()).toBe(0);
+            expect(sym2.colors).toEqual([]);
+        });
+
+        it('is case insensitive', () => {
+            const sym = UntapSymbol.fromString('{q}');
+            expect(sym.raw).toBe('Q');
+            expect(sym.type).toBe('untap');
+        });
+
+        it('throws for invalid input', () => {
+            expect(() => UntapSymbol.fromString('T')).toThrow(); // Tap, not Untap
+            expect(() => UntapSymbol.fromString('{W}')).toThrow();
+            expect(() => UntapSymbol.fromString('')).toThrow();
+        });
+    });
+
+    describe('properties', () => {
+        it('has type untap', () => {
+            const sym = UntapSymbol.fromString('Q');
+            expect(sym.type).toBe('untap');
+        });
+
+        it('cmcValue is always 0', () => {
+            const sym = UntapSymbol.fromString('{Q}');
+            expect(sym.cmcValue()).toBe(0);
+        });
+
+        it('colors is always empty', () => {
+            const sym = UntapSymbol.fromString('Q');
+            expect(sym.colors).toEqual([]);
+        });
+    });
+
+    describe('inherited methods', () => {
+        it('apply() pushes to array', () => {
+            const arr = [];
+            const sym = UntapSymbol.fromString('Q');
+            sym.apply(arr);
+            expect(arr[0]).toBe(sym);
+        });
+
+        it('toString() outputs correctly', () => {
+            const sym = UntapSymbol.fromString('{Q}');
+            expect(sym.toString(false)).toBe('Q');
+            expect(sym.toString(true)).toBe('{Q}');
+        });
+    });
+
+    describe('roundtrip', () => {
+        it('parses and serializes symmetrically', () => {
+            const input = '{Q}';
+            const sym1 = UntapSymbol.fromString(input);
+            const str = sym1.toString(true);
+            const sym2 = UntapSymbol.fromString(str);
+            expect(sym2.raw).toBe('Q');
+            expect(sym2.type).toBe('untap');
+        });
+    });
+});

package/tests/symbols/VariableManaSymbol.test.js

@@ -0,0 +1,72 @@
+import VariableManaSymbol from '../../src/symbols/VariableManaSymbol.js';
+
+describe('VariableManaSymbol', () => {
+    describe('fromString()', () => {
+        it('creates a symbol from variable (shortform and braced)', () => {
+            for (const v of ['X','Y','Z']) {
+                const sym1 = VariableManaSymbol.fromString(v);
+                expect(sym1.raw).toBe(v);
+                expect(sym1.cmcValue()).toBe(0);
+
+                const sym2 = VariableManaSymbol.fromString(`{${v}}`);
+                expect(sym2.raw).toBe(v);
+                expect(sym2.cmcValue()).toBe(0);
+            }
+        });
+
+        it('is case insensitive', () => {
+            const sym = VariableManaSymbol.fromString('{x}');
+            expect(sym.raw).toBe('X');
+            expect(sym.cmcValue()).toBe(0);
+        });
+
+        it('throws for invalid input', () => {
+            expect(() => VariableManaSymbol.fromString('W')).toThrow();
+            expect(() => VariableManaSymbol.fromString('1')).toThrow();
+            expect(() => VariableManaSymbol.fromString('')).toThrow();
+        });
+    });
+
+    describe('properties', () => {
+        it('has type variable', () => {
+            const sym = VariableManaSymbol.fromString('X');
+            expect(sym.type).toBe('variableMana');
+        });
+
+        it('cmcValue is always 0', () => {
+            const sym = VariableManaSymbol.fromString('{Y}');
+            expect(sym.cmcValue()).toBe(0);
+        });
+
+        it('colors is always empty', () => {
+            const sym = VariableManaSymbol.fromString('Z');
+            expect(sym.colors).toEqual([]);
+        });
+    });
+
+    describe('inherited methods', () => {
+        it('apply() pushes to array', () => {
+            const arr = [];
+            const sym = VariableManaSymbol.fromString('X');
+            sym.apply(arr);
+            expect(arr[0]).toBe(sym);
+        });
+
+        it('toString() outputs correctly', () => {
+            const sym = VariableManaSymbol.fromString('{Y}');
+            expect(sym.toString(false)).toBe('Y');
+            expect(sym.toString(true)).toBe('{Y}');
+        });
+    });
+
+    describe('roundtrip', () => {
+        it('parses and serializes symmetrically', () => {
+            const input = '{Z}';
+            const sym1 = VariableManaSymbol.fromString(input);
+            const str = sym1.toString(true);
+            const sym2 = VariableManaSymbol.fromString(str);
+            expect(sym2.raw).toBe('Z');
+            expect(sym2.cmcValue()).toBe(0);
+        });
+    });
+});